fix(map): use Agent API endpoint for generatePlan (#4)

- Changed from /api/v1/orchestrator/plan to /api/request with
  request_type: 'multi-agent-plan' to match other SDKs
- Added parsePlanResponse() to handle Agent API response format
  (nested data.steps, data.domain, etc.)
- Updated test to use new endpoint and response format
- Fixed null-safety issues with Map.of() by using HashMap

Author: saurabhjain1592

CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to the AxonFlow Java SDK will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Fixed
+
+- **MAP Endpoint** - Fixed `generatePlan()` to use correct Agent API endpoint
+  - Changed from `/api/v1/orchestrator/plan` to `/api/request` with `request_type: "multi-agent-plan"`
+  - Added proper response parsing for Agent API format
+  - Fixed null-safety issues with request context
+
+## [1.1.0] - 2025-12-19
+
+### Added
+
+- **LLM Interceptors** - Transparent governance for LLM API calls (#1)
+  - `OpenAIInterceptor` for OpenAI API interception
+  - `AnthropicInterceptor` for Anthropic API interception
+  - `GeminiInterceptor` for Google Generative AI interception
+  - Policy enforcement and audit logging for all providers
+- Full feature parity with other SDKs for LLM interceptors
+- **Self-Hosted Zero-Config Tests** - Auth header verification for localhost (#2)
+  - Tests verify auth headers are skipped for localhost endpoints
+
+## [1.0.0] - 2025-12-04
+
+### Added
+
+- Initial release of AxonFlow Java SDK
+- Core client with `executeQuery()` for governed AI calls
+- Policy enforcement with `PolicyViolationException`
+- **Gateway Mode** support
+  - `getPolicyApprovedContext()` for pre-checks
+  - `auditLLMCall()` for compliance logging
+- **Multi-Agent Planning**
+  - `generatePlan()` for creating execution plans
+  - `executePlan()` for running plans
+  - `getPlanStatus()` for checking plan status
+- **MCP Connectors**
+  - `listConnectors()` for available connectors
+  - `installConnector()` for connector installation
+  - `queryConnector()` for connector queries
+- Comprehensive type definitions with Jackson
+- Retry logic with exponential backoff (OkHttp)
+- Response caching with Caffeine
+- Self-hosted mode for localhost deployments
+- Java 11+ compatibility
+- Maven Central publishing support

src/main/java/com/getaxonflow/sdk/AxonFlow.java

@@ -30,6 +30,7 @@
 
 import java.io.Closeable;
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -361,6 +362,9 @@ public CompletableFuture<ClientResponse> executeQueryAsync(ClientRequest request
     /**
      * Generates a multi-agent plan for a complex task.
      *
+     * <p>This method uses the Agent API with request_type "multi-agent-plan"
+     * to generate and execute plans through the governance layer.
+     *
      * @param request the plan request
      * @return the generated plan
      * @throws PlanExecutionException if plan generation fails
@@ -369,13 +373,83 @@ public PlanResponse generatePlan(PlanRequest request) {
         Objects.requireNonNull(request, "request cannot be null");
 
         return retryExecutor.execute(() -> {
-            Request httpRequest = buildRequest("POST", "/api/v1/orchestrator/plan", request);
+            // Build agent request format - use HashMap to allow null-safe values
+            String userToken = request.getUserToken();
+            if (userToken == null) {
+                userToken = config.getClientId() != null ? config.getClientId() : "default";
+            }
+            String clientId = config.getClientId() != null ? config.getClientId() : "default";
+            String domain = request.getDomain() != null ? request.getDomain() : "generic";
+
+            Map<String, Object> agentRequest = new java.util.HashMap<>();
+            agentRequest.put("query", request.getObjective());
+            agentRequest.put("user_token", userToken);
+            agentRequest.put("client_id", clientId);
+            agentRequest.put("request_type", "multi-agent-plan");
+            agentRequest.put("context", Map.of("domain", domain));
+
+            Request httpRequest = buildRequest("POST", "/api/request", agentRequest);
             try (Response response = httpClient.newCall(httpRequest).execute()) {
-                return parseResponse(response, PlanResponse.class);
+                return parsePlanResponse(response, request.getDomain());
             }
         }, "generatePlan");
     }
 
+    /**
+     * Parses the Agent API response format into PlanResponse.
+     * The Agent API returns: {success, plan_id, data: {steps, domain, ...}, metadata, result}
+     */
+    @SuppressWarnings("unchecked")
+    private PlanResponse parsePlanResponse(Response response, String requestDomain) throws IOException {
+        handleErrorResponse(response);
+
+        ResponseBody body = response.body();
+        if (body == null) {
+            throw new AxonFlowException("Empty response body", response.code(), null);
+        }
+
+        String json = body.string();
+        Map<String, Object> agentResponse = objectMapper.readValue(json,
+            new TypeReference<Map<String, Object>>() {});
+
+        // Check for errors
+        Boolean success = (Boolean) agentResponse.get("success");
+        if (success == null || !success) {
+            String error = (String) agentResponse.get("error");
+            throw new PlanExecutionException(error != null ? error : "Plan generation failed");
+        }
+
+        // Extract fields from Agent API response format
+        String planId = (String) agentResponse.get("plan_id");
+        Map<String, Object> data = (Map<String, Object>) agentResponse.get("data");
+        Map<String, Object> metadata = (Map<String, Object>) agentResponse.get("metadata");
+        String result = (String) agentResponse.get("result");
+
+        // Extract nested fields from data
+        List<PlanStep> steps = Collections.emptyList();
+        String domain = requestDomain != null ? requestDomain : "generic";
+        Integer complexity = null;
+        Boolean parallel = null;
+        String estimatedDuration = null;
+
+        if (data != null) {
+            // Parse steps if present
+            List<Map<String, Object>> rawSteps = (List<Map<String, Object>>) data.get("steps");
+            if (rawSteps != null) {
+                steps = rawSteps.stream()
+                    .map(stepMap -> objectMapper.convertValue(stepMap, PlanStep.class))
+                    .toList();
+            }
+            domain = data.get("domain") != null ? (String) data.get("domain") : domain;
+            complexity = data.get("complexity") != null ? ((Number) data.get("complexity")).intValue() : null;
+            parallel = (Boolean) data.get("parallel");
+            estimatedDuration = (String) data.get("estimated_duration");
+        }
+
+        return new PlanResponse(planId, steps, domain, complexity, parallel,
+            estimatedDuration, metadata, null, result);
+    }
+
     /**
      * Asynchronously generates a multi-agent plan.
      *

src/test/java/com/getaxonflow/sdk/AxonFlowTest.java

@@ -229,11 +229,12 @@ void generatePlanShouldRequireRequest() {
     @Test
     @DisplayName("generatePlanAsync should return future")
     void generatePlanAsyncShouldReturnFuture() throws Exception {
-        stubFor(post(urlEqualTo("/api/v1/orchestrator/plan"))
+        // Now uses Agent API endpoint with request_type: multi-agent-plan
+        stubFor(post(urlEqualTo("/api/request"))
             .willReturn(aResponse()
                 .withStatus(200)
                 .withHeader("Content-Type", "application/json")
-                .withBody("{\"plan_id\":\"plan_123\",\"steps\":[]}")));
+                .withBody("{\"success\":true,\"plan_id\":\"plan_123\",\"data\":{\"steps\":[]}}")));
 
         PlanRequest request = PlanRequest.builder()
             .objective("test")