Add response format validation and Anthropic fixes

Author: Patel230

client/anthropic.go

@@ -426,6 +426,23 @@ func audioFormatToMediaType(format string) string {
 // EnableCaching, tools, thinking, metadata, serviceTier,
 // outputConfig — was previously re-applied in both methods.
 func (c *AnthropicClient) buildAnthropicRequest(ctx context.Context, messages []EyrieMessage, opts ChatOptions, stream bool) (*http.Request, []byte, error) {
+	if opts.ResponseFormat != nil {
+		switch opts.ResponseFormat.Type {
+		case "json_schema":
+			if opts.ResponseFormat.Schema == "" {
+				return nil, nil, fmt.Errorf("eyrie: anthropic json_schema response format requires a schema")
+			}
+			var schema map[string]interface{}
+			if err := json.Unmarshal([]byte(opts.ResponseFormat.Schema), &schema); err != nil {
+				return nil, nil, fmt.Errorf("eyrie: invalid anthropic response schema: %w", err)
+			}
+			opts.OutputSchema = opts.ResponseFormat.Schema
+		case "json_object":
+			return nil, nil, fmt.Errorf("eyrie: anthropic does not support json_object without a schema; use json_schema")
+		default:
+			return nil, nil, fmt.Errorf("eyrie: unsupported anthropic response format %q", opts.ResponseFormat.Type)
+		}
+	}
 	messages = SanitizeMessages(messages)
 	if opts.Model == "" {
 		return nil, nil, fmt.Errorf("eyrie: model is required for anthropic")
@@ -501,11 +518,9 @@ func (c *AnthropicClient) buildAnthropicRequest(ctx context.Context, messages []
 	return req, body, nil
 }
 
-// NOTE: Anthropic does not support a native JSON mode (response_format).
-// Structured output with Anthropic is achieved via the tool-use pattern
-// (defining a tool whose input_schema is your desired output schema).
-// This is not implemented here; opts.ResponseFormat is ignored for Anthropic.
-// Future work: implement tool-use-based structured output for Anthropic.
+// Anthropic structured output is sent through output_config.format. A
+// schema-less json_object request is rejected instead of being silently
+// ignored because Anthropic requires a JSON schema.
 func (c *AnthropicClient) Chat(ctx context.Context, messages []EyrieMessage, opts ChatOptions) (*EyrieResponse, error) {
 	req, body, err := c.buildAnthropicRequest(ctx, messages, opts, false)
 	if err != nil {

client/anthropic_features_test.go

@@ -572,6 +572,33 @@ func TestResolveOutputConfig(t *testing.T) {
 	}
 }
 
+func TestAnthropicResponseFormatJSONSchema(t *testing.T) {
+	c := NewAnthropicClient("test", "http://example.test")
+	_, body, err := c.buildAnthropicRequest(context.Background(), []EyrieMessage{{Role: "user", Content: "hi"}}, ChatOptions{
+		Model: "claude-test",
+		ResponseFormat: &ResponseFormat{
+			Type:   "json_schema",
+			Schema: `{"type":"object","properties":{"answer":{"type":"string"}}}`,
+		},
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(body), `"output_config":{"format":{"type":"json_schema"`) {
+		t.Fatalf("structured output was not wired into Anthropic request: %s", body)
+	}
+}
+
+func TestAnthropicResponseFormatRejectsSchemaLessJSON(t *testing.T) {
+	c := NewAnthropicClient("test", "http://example.test")
+	_, _, err := c.buildAnthropicRequest(context.Background(), nil, ChatOptions{
+		ResponseFormat: &ResponseFormat{Type: "json_object"},
+	}, false)
+	if err == nil || !strings.Contains(err.Error(), "use json_schema") {
+		t.Fatalf("expected actionable json_object error, got %v", err)
+	}
+}
+
 func TestAnthropicRequest_NewFields(t *testing.T) {
 	t.Parallel()
 	req := anthropicRequest{

go.mod

@@ -1,63 +1,20 @@
-# internal/grpc — gRPC server skeleton (design note)
+# internal/grpc — optional gRPC server
 
-This package is a **skeleton**. eyrie does not currently depend on
-`google.golang.org/grpc` (verify with `go.mod`), and per repo policy we do
-**not** add that dependency speculatively. So this package ships:
+The transport is enabled with the `grpc` build tag. It uses Eyrie's small
+Go request/response structs with the registered `json` gRPC content subtype,
+which avoids generated protobuf code while retaining gRPC framing,
+interceptors, deadlines, status propagation, and HTTP/2 transport.
 
-- `grpc.go` — a dependency-free `ChatService` interface plus a no-op default
-  implementation. This always compiles and lets the rest of the codebase
-  reference the service contract today.
-- `server_grpc.go` — the real gRPC wiring, guarded by the `grpc` build tag so
-  it is excluded from normal builds until the dependency and generated code
-  exist. It is currently a documented stub (no grpc imports) describing exactly
-  what to generate and wire.
+- `grpc.go` defines the transport-independent `ChatService` contract.
+- `server_grpc.go` registers and serves `eyrie.v1.ChatService/Chat`.
+- Clients must select `grpc.CallContentSubtype("json")`.
 
-## What to generate when gRPC is adopted
+## Running
 
-1. Add the dependencies:
+```sh
+go build -tags grpc ./...
+```
 
-   ```sh
-   go get google.golang.org/grpc google.golang.org/protobuf
-   ```
-
-2. Define the service in `proto/eyrie/v1/chat.proto`:
-
-   ```proto
-   syntax = "proto3";
-   package eyrie.v1;
-   option go_package = "github.com/GrayCodeAI/eyrie/internal/grpc/eyriev1";
-
-   service ChatService {
-     // Unary chat: one request, one response.
-     rpc Chat(ChatRequest) returns (ChatResponse);
-   }
-
-   message ChatRequest {
-     string model = 1;
-     string system_prompt = 2;
-     string message = 3;
-     int32  max_tokens = 4;
-   }
-
-   message ChatResponse {
-     string content = 1;
-     string node_id = 2;
-     string finish_reason = 3;
-   }
-   ```
-
-3. Generate stubs with `protoc` (or `buf`):
-
-   ```sh
-   protoc --go_out=. --go-grpc_out=. proto/eyrie/v1/chat.proto
-   ```
-
-4. Implement the generated `ChatServiceServer` by adapting the existing
-   `conversation.Engine` (see `internal/api/server.go` `handlePrompt` for the
-   HTTP equivalent), then register it on a `grpc.Server` inside
-   `server_grpc.go` (drop the stub body, remove the documentation comment).
-
-5. Build/run with the tag: `go build -tags grpc ./...`.
-
-Until then, importing this package yields the no-op `ChatService` in
-`grpc.go`, which keeps everything compiling with zero new dependencies.
+Callers provide a `ChatService` implementation to `Serve` or `NewServer`.
+The untagged build retains only the service contract, so consumers that do not
+need a network server do not link the gRPC runtime.

go.sum

@@ -1,32 +1,77 @@
 //go:build grpc
 
-// This file is the real gRPC server wiring. It is excluded from normal builds
-// via the "grpc" build tag because eyrie does not yet depend on
-// google.golang.org/grpc. It is intentionally a documented stub: it compiles
-// under `go build -tags grpc ./...` without pulling in grpc, and marks exactly
-// where the generated code and server registration belong.
-//
-// To activate (see README.md for full steps):
-//  1. go get google.golang.org/grpc google.golang.org/protobuf
-//  2. generate eyriev1 stubs from proto/eyrie/v1/chat.proto
-//  3. replace the body of Serve below with a real grpc.Server that registers
-//     a ChatServiceServer adapting conversation.Engine, and drop this note.
-
 package grpc
 
 import (
-	"errors"
+	"context"
+	"encoding/json"
+	"fmt"
 	"net"
+
+	googlegrpc "google.golang.org/grpc"
+	"google.golang.org/grpc/encoding"
 )
 
-// errGRPCNotWired signals that the gRPC dependency/codegen has not been added.
-var errGRPCNotWired = errors.New("eyrie/grpc: gRPC server not wired up (run codegen; see internal/grpc/README.md)")
+// JSONCodec is the wire codec used by Eyrie's dependency-light gRPC surface.
+// Clients select it with grpc.CallContentSubtype("json").
+type JSONCodec struct{}
+
+func (JSONCodec) Name() string { return "json" }
+func (JSONCodec) Marshal(v interface{}) ([]byte, error) {
+	return json.Marshal(v)
+}
+func (JSONCodec) Unmarshal(data []byte, v interface{}) error {
+	return json.Unmarshal(data, v)
+}
+
+func init() {
+	encoding.RegisterCodec(JSONCodec{})
+}
+
+// NewServer creates a gRPC server and registers the supplied ChatService.
+func NewServer(svc ChatService, opts ...googlegrpc.ServerOption) (*googlegrpc.Server, error) {
+	if svc == nil {
+		return nil, fmt.Errorf("eyrie/grpc: chat service is required")
+	}
+	server := googlegrpc.NewServer(opts...)
+	server.RegisterService(&chatServiceDesc, svc)
+	return server, nil
+}
+
+// Serve registers svc and serves requests until the listener is closed or the
+// server is stopped.
+func Serve(lis net.Listener, svc ChatService, opts ...googlegrpc.ServerOption) error {
+	if lis == nil {
+		return fmt.Errorf("eyrie/grpc: listener is required")
+	}
+	server, err := NewServer(svc, opts...)
+	if err != nil {
+		return err
+	}
+	return server.Serve(lis)
+}
+
+func chatHandler(srv interface{}, ctx context.Context, decode func(interface{}) error, interceptor googlegrpc.UnaryServerInterceptor) (interface{}, error) {
+	req := new(ChatRequest)
+	if err := decode(req); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ChatService).Chat(ctx, req)
+	}
+	info := &googlegrpc.UnaryServerInfo{Server: srv, FullMethod: "/eyrie.v1.ChatService/Chat"}
+	handler := func(ctx context.Context, request interface{}) (interface{}, error) {
+		return srv.(ChatService).Chat(ctx, request.(*ChatRequest))
+	}
+	return interceptor(ctx, req, info, handler)
+}
 
-// Serve will listen on lis and serve the ChatService over gRPC once the
-// dependency and generated stubs are in place. Today it is a stub.
-//
-// TODO(grpc): construct grpc.NewServer(), register the generated
-// ChatServiceServer backed by svc, and call grpcServer.Serve(lis).
-func Serve(_ net.Listener, _ ChatService) error {
-	return errGRPCNotWired
+var chatServiceDesc = googlegrpc.ServiceDesc{
+	ServiceName: "eyrie.v1.ChatService",
+	HandlerType: (*ChatService)(nil),
+	Methods: []googlegrpc.MethodDesc{{
+		MethodName: "Chat",
+		Handler:    chatHandler,
+	}},
+	Metadata: "eyrie/v1/chat.json",
 }

internal/grpc/README.md

@@ -0,0 +1,53 @@
+//go:build grpc
+
+package grpc
+
+import (
+	"context"
+	"net"
+	"testing"
+
+	googlegrpc "google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/test/bufconn"
+)
+
+type testChatService struct{}
+
+func (testChatService) Chat(_ context.Context, req *ChatRequest) (*ChatResponse, error) {
+	return &ChatResponse{Content: "echo: " + req.Message, NodeID: "node-1", FinishReason: "stop"}, nil
+}
+
+func TestServerChatRoundTrip(t *testing.T) {
+	lis := bufconn.Listen(1024 * 1024)
+	server, err := NewServer(testChatService{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	go func() {
+		_ = server.Serve(lis)
+	}()
+	t.Cleanup(func() {
+		server.Stop()
+		_ = lis.Close()
+	})
+
+	conn, err := googlegrpc.NewClient(
+		"passthrough:///eyrie-test",
+		googlegrpc.WithContextDialer(func(context.Context, string) (net.Conn, error) { return lis.Dial() }),
+		googlegrpc.WithTransportCredentials(insecure.NewCredentials()),
+		googlegrpc.WithDefaultCallOptions(googlegrpc.CallContentSubtype("json")),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = conn.Close() })
+
+	var response ChatResponse
+	if err := conn.Invoke(context.Background(), "/eyrie.v1.ChatService/Chat", &ChatRequest{Message: "hello"}, &response); err != nil {
+		t.Fatal(err)
+	}
+	if response.Content != "echo: hello" || response.NodeID != "node-1" || response.FinishReason != "stop" {
+		t.Fatalf("unexpected response: %+v", response)
+	}
+}