Agent Executor (AX) is Google's open agentic orchestration runtime
Go
Add AXEventLogService (#194)
Jaana Doganedcd9d8edd0f
diff --git a/internal/controller/controller.go b/internal/controller/controller.goindex 1cf1157..59fcffd 100644--- a/internal/controller/controller.go+++ b/internal/controller/controller.go@@ -28,8 +28,6 @@ import ("github.com/google/ax/internal/testagent""github.com/google/ax/proto""github.com/google/uuid"- "google.golang.org/grpc/codes"- "google.golang.org/grpc/status""google.golang.org/protobuf/types/known/anypb")@@ -252,10 +250,16 @@ func (d *Controller) execute(ctx context.Context, conversationID string, execIDreturn err}-// Fork forks an execution from a source execution.-// If checkpointId is provided, fork til the checkpoint. Otherwise, fork the whole execution.-func (d *Controller) Fork(ctx context.Context, sourceID, sourceCheckpoint, destID string) error {- return status.Errorf(codes.Unimplemented, "forking is not supported yet")+// Delete deletes all events for a specific conversation ID.+func (d *Controller) Delete(ctx context.Context, conversationID string) error {+ d.inFlightMu.Lock()+ _, ok := d.inFlight[conversationID]+ d.inFlightMu.Unlock()+ if ok {+ return fmt.Errorf("conversation %q is in flight, cannot delete", conversationID)+ }++ return d.eventLog.DeleteEvents(ctx, conversationID)}// Registry returns the agent registry.diff --git a/internal/controller/controller_test.go b/internal/controller/controller_test.goindex 9c732d3..5a34caf 100644--- a/internal/controller/controller_test.go+++ b/internal/controller/controller_test.go@@ -16,58 +16,14 @@ package controllerimport ("context"- "sync""testing""github.com/google/ax/internal/agent""github.com/google/ax/internal/controller/executor"+ "github.com/google/ax/internal/controller/executor/executortest""github.com/google/ax/proto")-type mockEventLog struct {- mu sync.Mutex- events []*proto.ConversationEvent- execEvents []*proto.ExecutionEvent-}--func (m *mockEventLog) Append(ctx context.Context, event *proto.ConversationEvent) (int32, error) {- m.mu.Lock()- defer m.mu.Unlock()- seq := int32(len(m.events) + 1)- event.Seq = seq- m.events = append(m.events, event)- return seq, nil-}--func (m *mockEventLog) AppendExec(ctx context.Context, event *proto.ExecutionEvent) error {- m.execEvents = append(m.execEvents, event)- return nil-}--func (m *mockEventLog) Events(ctx context.Context, conversationID string) ([]*proto.ConversationEvent, error) {- var out []*proto.ConversationEvent- for _, ev := range m.events {- if ev.ConversationId == conversationID {- out = append(out, ev)- }- }- return out, nil-}--func (m *mockEventLog) ExecEvents(ctx context.Context, execID string) ([]*proto.ExecutionEvent, error) {- var out []*proto.ExecutionEvent- for _, ev := range m.execEvents {- if ev.ExecId == execID {- out = append(out, ev)- }- }- return out, nil-}--func (m *mockEventLog) Close() error {- return nil-}-type dummyAgent struct{}func (a *dummyAgent) Connect(ctx context.Context, execID string, start *proto.AgentStart, e agent.Executor, o agent.OutputHandler) error {@@ -92,7 +48,7 @@ func TestController_Exec_ResumptionAndIDGeneration(t *testing.T) {}// Case 1: No history, new inputs. Should create a new execution with a UUID.- log := &mockEventLog{}+ log := &executortest.MemoryEventLog{}c, err := New(ctx, Config{EventLogBuilder: func() (executor.EventLog, error) {return log, nil@@ -113,17 +69,17 @@ func TestController_Exec_ResumptionAndIDGeneration(t *testing.T) {if err != nil {t.Fatal(err)}- if len(log.events) == 0 {+ if len(log.AllEvents) == 0 {t.Fatal("expected events to be logged")}- execID := log.events[0].ExecId+ execID := log.AllEvents[0].ExecIdif execID == "" || execID == cid {t.Fatalf("expected a new random execID, got %v", execID)}// Case 2: History exists, PENDING state, inputs empty. Should replay/resume.// Modify the event logged by logPending in Case 1 to use dummy-agent.- log.events[len(log.events)-1].State = proto.State_STATE_PENDING+ log.AllEvents[len(log.AllEvents)-1].State = proto.State_STATE_PENDINGerr = c.Exec(ctx, &proto.ExecRequest{ConversationId: cid,@@ -133,22 +89,22 @@ func TestController_Exec_ResumptionAndIDGeneration(t *testing.T) {t.Fatal(err)}// Replay should have called `e.Exec` for that `execID`.- lastEventID := log.events[len(log.events)-1].ExecId+ lastEventID := log.AllEvents[len(log.AllEvents)-1].ExecIdif lastEventID != execID {t.Fatalf("expected resumed execution ID %v, got %v", execID, lastEventID)}// Case 3: History exists, COMPLETED state, new inputs. Should create a NEW execution.- for _, ev := range log.execEvents {+ for _, ev := range log.AllExecEvents {if ev.ExecId == execID {ev.State = proto.State_STATE_COMPLETED}}// Also populate messages in conversation log to simulate completion.- log.events[len(log.events)-1].Messages = []*proto.Message{+ log.AllEvents[len(log.AllEvents)-1].Messages = []*proto.Message{{Role: "user", Content: &proto.Content{Content: &proto.Content_Text{Text: &proto.TextContent{Text: "hello"}}}},}- log.events[len(log.events)-1].State = proto.State_STATE_COMPLETED+ log.AllEvents[len(log.AllEvents)-1].State = proto.State_STATE_COMPLETEDerr = c.Exec(ctx, &proto.ExecRequest{ConversationId: cid,@@ -158,7 +114,7 @@ func TestController_Exec_ResumptionAndIDGeneration(t *testing.T) {t.Fatal(err)}- newExecID := log.events[len(log.events)-1].ExecId+ newExecID := log.AllEvents[len(log.AllEvents)-1].ExecIdif newExecID == execID {t.Fatal("expected a NEW execution ID, but it was reused")}@@ -168,9 +124,9 @@ func TestController_Exec_LastSeenSeq_Empty(t *testing.T) {ctx := context.Background()cid := "test-conv-seq"- log := &mockEventLog{}+ log := &executortest.MemoryEventLog{}// Pre-populate history- log.events = []*proto.ConversationEvent{+ log.AllEvents = []*proto.ConversationEvent{{ConversationId: cid,Seq: 1,@@ -223,9 +179,9 @@ func TestController_Exec_LastSeenSeq(t *testing.T) {ctx := context.Background()cid := "test-conv-seq"- log := &mockEventLog{}+ log := &executortest.MemoryEventLog{}// Pre-populate history- log.events = []*proto.ConversationEvent{+ log.AllEvents = []*proto.ConversationEvent{{ConversationId: cid,Seq: 1,@@ -285,10 +241,10 @@ func TestController_Exec_WaitsForConfirmation(t *testing.T) {cid := "test-conv-conf"execID := "test-exec-conf"- log := &mockEventLog{}+ log := &executortest.MemoryEventLog{}// 1. History has a pending execution.- log.events = []*proto.ConversationEvent{+ log.AllEvents = []*proto.ConversationEvent{{ConversationId: cid,ExecId: execID,@@ -309,7 +265,7 @@ func TestController_Exec_WaitsForConfirmation(t *testing.T) {},}- log.execEvents = []*proto.ExecutionEvent{+ log.AllExecEvents = []*proto.ExecutionEvent{{ExecId: execID,AgentId: "__planner",@@ -360,7 +316,7 @@ func TestController_Exec_InternalOnly(t *testing.T) {ctx := context.Background()cid := "test-conv-internal"- log := &mockEventLog{}+ log := &executortest.MemoryEventLog{}// Create an agent that emits one internal-only message and one regular message.a := &mockAgentFunc{@@ -427,23 +383,23 @@ func TestController_Exec_InternalOnly(t *testing.T) {}// Verify that internal messages are NOT stored in ConversationEvent.- if len(log.events) != 3 {- t.Fatalf("expected 3 events in log.events, got %d", len(log.events))+ if len(log.AllEvents) != 3 {+ t.Fatalf("expected 3 events in log.AllEvents, got %d", len(log.AllEvents))}// Event 0: Inputs// Event 1: Public message- if log.events[1].Messages[0].GetContent().GetText().GetText() != "public message" {- t.Fatalf("expected 'public message' in log.events, got %v", log.events[1].Messages[0].GetContent().GetText().GetText())+ if log.AllEvents[1].Messages[0].GetContent().GetText().GetText() != "public message" {+ t.Fatalf("expected 'public message' in log.AllEvents, got %v", log.AllEvents[1].Messages[0].GetContent().GetText().GetText())}// Verify that BOTH messages ARE stored in ExecutionEvent.- if len(log.execEvents) != 3 {- t.Fatalf("expected 3 events in log.execEvents, got %d", len(log.execEvents))+ if len(log.AllExecEvents) != 3 {+ t.Fatalf("expected 3 events in log.AllExecEvents, got %d", len(log.AllExecEvents))}// Event 1 in execEvents should contain both outputs.- outputs := log.execEvents[1].Outputs+ outputs := log.AllExecEvents[1].Outputsif len(outputs) != 2 {t.Fatalf("expected 2 outputs in execEvent, got %d", len(outputs))}diff --git a/internal/controller/executor/eventlog.go b/internal/controller/executor/eventlog.goindex bd62aeb..4f52302 100644--- a/internal/controller/executor/eventlog.go+++ b/internal/controller/executor/eventlog.go@@ -37,6 +37,9 @@ type EventLog interface {// ExecEvents returns all events for a specific execution ID.ExecEvents(ctx context.Context, execID string) ([]*proto.ExecutionEvent, error)+ // DeleteEvents deletes all events for a specific conversation ID.+ DeleteEvents(ctx context.Context, conversationID string) error+// Close releases the underlying resources and closes the log.Close() error}diff --git a/internal/controller/executor/executor_test.go b/internal/controller/executor/executor_test.goindex cf69be9..f15dcb6 100644--- a/internal/controller/executor/executor_test.go+++ b/internal/controller/executor/executor_test.go@@ -19,91 +19,20 @@ import ("fmt""log""strings"- "sync""sync/atomic""testing""time""github.com/google/ax/internal/agent"+ "github.com/google/ax/internal/controller/executor/executortest""github.com/google/ax/internal/historyutil""github.com/google/ax/proto""golang.org/x/sync/errgroup")-// MemoryEventLog is an in-memory EventLog useful for testing and short-lived-// executions. It does not survive process restarts.-type MemoryEventLog struct {- mu sync.Mutex- events []*proto.ConversationEvent- execEvents []*proto.ExecutionEvent-}--func (m *MemoryEventLog) Append(_ context.Context, event *proto.ConversationEvent) (int32, error) {- m.mu.Lock()- defer m.mu.Unlock()-- seq := int32(len(m.events) + 1)- event.Seq = seq- m.events = append(m.events, event)- return seq, nil-}--func (m *MemoryEventLog) AppendExec(_ context.Context, event *proto.ExecutionEvent) error {- m.mu.Lock()- defer m.mu.Unlock()-- m.execEvents = append(m.execEvents, event)- return nil-}--func (m *MemoryEventLog) Events(_ context.Context, conversationID string) ([]*proto.ConversationEvent, error) {- m.mu.Lock()- defer m.mu.Unlock()-- out := make([]*proto.ConversationEvent, 0)- for _, ev := range m.events {- if ev.ConversationId == conversationID {- out = append(out, ev)- }- }- return out, nil-}--func (m *MemoryEventLog) ExecEvents(_ context.Context, execID string) ([]*proto.ExecutionEvent, error) {- m.mu.Lock()- defer m.mu.Unlock()-- out := make([]*proto.ExecutionEvent, 0)- for _, ev := range m.execEvents {- if ev.ExecId == execID {- out = append(out, ev)- }- }- return out, nil-}--// Drop removes every event for which drop returns true.-// It is provided for testing and crash-simulation purposes.-func (m *MemoryEventLog) Drop(drop func(*proto.ConversationEvent) bool) {- m.mu.Lock()- defer m.mu.Unlock()-- kept := m.events[:0]- for _, ev := range m.events {- if !drop(ev) {- kept = append(kept, ev)- }- }- m.events = kept-}--func (m *MemoryEventLog) Close() error {- return nil-}--// memoryBuilder returns a new EventLogBuilder that creates a fresh MemoryEventLog per task.+// memoryEventLog returns a new EventLogBuilder that creates a fresh MemoryEventLog per task.func memoryEventLog() EventLog {- return &MemoryEventLog{}+ return &executortest.MemoryEventLog{}}func Example() {diff --git a/internal/controller/executor/executortest/eventlog.go b/internal/controller/executor/executortest/eventlog.gonew file mode 100644index 0000000..972283f--- /dev/null+++ b/internal/controller/executor/executortest/eventlog.go@@ -0,0 +1,128 @@+// Copyright 2026 Google LLC+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.++package executortest++import (+ "context"+ "sync"++ "github.com/google/ax/proto"+)++// MemoryEventLog is an in-memory EventLog useful for testing and short-lived+// executions. It does not survive process restarts.+type MemoryEventLog struct {+ mu sync.Mutex+ AllEvents []*proto.ConversationEvent+ AllExecEvents []*proto.ExecutionEvent+}++func (m *MemoryEventLog) Append(_ context.Context, event *proto.ConversationEvent) (int32, error) {+ m.mu.Lock()+ defer m.mu.Unlock()++ seq := int32(len(m.AllEvents) + 1)+ event.Seq = seq+ m.AllEvents = append(m.AllEvents, event)+ return seq, nil+}++func (m *MemoryEventLog) AppendExec(_ context.Context, event *proto.ExecutionEvent) error {+ m.mu.Lock()+ defer m.mu.Unlock()++ m.AllExecEvents = append(m.AllExecEvents, event)+ return nil+}++func (m *MemoryEventLog) Events(_ context.Context, conversationID string) ([]*proto.ConversationEvent, error) {+ m.mu.Lock()+ defer m.mu.Unlock()++ out := make([]*proto.ConversationEvent, 0)+ for _, ev := range m.AllEvents {+ if ev.ConversationId == conversationID {+ out = append(out, ev)+ }+ }+ return out, nil+}++func (m *MemoryEventLog) ExecEvents(_ context.Context, execID string) ([]*proto.ExecutionEvent, error) {+ m.mu.Lock()+ defer m.mu.Unlock()++ out := make([]*proto.ExecutionEvent, 0)+ for _, ev := range m.AllExecEvents {+ if ev.ExecId == execID {+ out = append(out, ev)+ }+ }+ return out, nil+}++// Drop removes every event for which drop returns true.+// It is provided for testing and crash-simulation purposes.+func (m *MemoryEventLog) Drop(drop func(*proto.ConversationEvent) bool) {+ m.mu.Lock()+ defer m.mu.Unlock()++ kept := m.AllEvents[:0]+ for _, ev := range m.AllEvents {+ if !drop(ev) {+ kept = append(kept, ev)+ }+ }+ m.AllEvents = kept+}++func (m *MemoryEventLog) DeleteEvents(_ context.Context, conversationID string) error {+ m.mu.Lock()+ defer m.mu.Unlock()++ var execIDs []string+ var keptEvents []*proto.ConversationEvent+ for _, ev := range m.AllEvents {+ if ev.ConversationId == conversationID {+ if ev.ExecId != "" {+ execIDs = append(execIDs, ev.ExecId)+ }+ } else {+ keptEvents = append(keptEvents, ev)+ }+ }+ m.AllEvents = keptEvents++ var keptExecEvents []*proto.ExecutionEvent+ for _, ev := range m.AllExecEvents {+ delete := false+ for _, id := range execIDs {+ if ev.ExecId == id {+ delete = true+ break+ }+ }+ if !delete {+ keptExecEvents = append(keptExecEvents, ev)+ }+ }+ m.AllExecEvents = keptExecEvents++ return nil+}++func (m *MemoryEventLog) Close() error {+ return nil+}diff --git a/internal/controller/executor/sqlite.go b/internal/controller/executor/sqlite.goindex e34921a..7f1c52f 100644--- a/internal/controller/executor/sqlite.go+++ b/internal/controller/executor/sqlite.go@@ -188,6 +188,62 @@ func (l *SQLiteEventLog) ExecEvents(ctx context.Context, execID string) ([]*protreturn events, nil}+// DeleteEvents deletes all events for a specific conversation ID and its child executions.+func (l *SQLiteEventLog) DeleteEvents(ctx context.Context, conversationID string) error {+ tx, err := l.db.BeginTx(ctx, nil)+ if err != nil {+ return fmt.Errorf("sqlite_eventlog: begin tx: %w", err)+ }+ defer tx.Rollback()++ // TODO(jbd): Update the schema to include conversation_id at every execution event.++ // Get all exec_ids for this conversation+ rows, err := tx.QueryContext(ctx, "SELECT payload FROM conversation_log WHERE conversation_id = ?", conversationID)+ if err != nil {+ return fmt.Errorf("sqlite_eventlog: query conversation: %w", err)+ }+ defer rows.Close()++ var execIDs []string+ for rows.Next() {+ var payload string+ if err := rows.Scan(&payload); err != nil {+ return fmt.Errorf("sqlite_eventlog: scan conversation: %w", err)+ }++ ev := &proto.ConversationEvent{}+ if err := unmarshalOpts.Unmarshal([]byte(payload), ev); err != nil {+ return fmt.Errorf("sqlite_eventlog: unmarshal event: %w", err)+ }+ if ev.ExecId != "" {+ execIDs = append(execIDs, ev.ExecId)+ }+ }++ if err := rows.Err(); err != nil {+ return fmt.Errorf("sqlite_eventlog: iterate conversation: %w", err)+ }++ // Delete from execution_log+ for _, execID := range execIDs {+ if _, err := tx.ExecContext(ctx, "DELETE FROM execution_log WHERE exec_id = ?", execID); err != nil {+ return fmt.Errorf("sqlite_eventlog: delete exec %s: %w", execID, err)+ }+ }++ // Delete from conversation_log+ if _, err := tx.ExecContext(ctx, "DELETE FROM conversation_log WHERE conversation_id = ?", conversationID); err != nil {+ return fmt.Errorf("sqlite_eventlog: delete conversation: %w", err)+ }++ if err := tx.Commit(); err != nil {+ return fmt.Errorf("sqlite_eventlog: commit tx: %w", err)+ }++ return nil+}+// Close releases the database connection.func (l *SQLiteEventLog) Close() error {return l.db.Close()diff --git a/internal/controller/executor/sqlite_test.go b/internal/controller/executor/sqlite_test.goindex 91382e1..185ecb3 100644--- a/internal/controller/executor/sqlite_test.go+++ b/internal/controller/executor/sqlite_test.go@@ -159,6 +159,81 @@ func TestSQLiteEventLog_Empty(t *testing.T) {}}+func TestSQLiteEventLog_DeleteEvents(t *testing.T) {+ ctx := context.Background()+ dbPath := filepath.Join(t.TempDir(), "test.db")++ log, err := OpenSQLiteEventLog(dbPath)+ if err != nil {+ t.Fatalf("failed to open sqlite event log: %v", err)+ }+ defer log.Close()++ // Setup data+ cev1 := &proto.ConversationEvent{ConversationId: "conv-1", Seq: 1, ExecId: "task-1"}+ cev2 := &proto.ConversationEvent{ConversationId: "conv-1", Seq: 2, ExecId: "task-2"}+ cev3 := &proto.ConversationEvent{ConversationId: "conv-2", Seq: 1, ExecId: "task-3"}++ log.Append(ctx, cev1)+ log.Append(ctx, cev2)+ log.Append(ctx, cev3)++ ee1 := &proto.ExecutionEvent{ExecId: "task-1", State: proto.State_STATE_PENDING}+ ee2 := &proto.ExecutionEvent{ExecId: "task-2", State: proto.State_STATE_COMPLETED}+ ee3 := &proto.ExecutionEvent{ExecId: "task-3", State: proto.State_STATE_PENDING}++ log.AppendExec(ctx, ee1)+ log.AppendExec(ctx, ee2)+ log.AppendExec(ctx, ee3)++ // Delete conv-1+ if err := log.DeleteEvents(ctx, "conv-1"); err != nil {+ t.Fatalf("failed to delete events: %v", err)+ }++ // Verify conversation events+ events, err := log.Events(ctx, "conv-1")+ if err != nil {+ t.Fatalf("failed to read events: %v", err)+ }+ if len(events) != 0 {+ t.Errorf("expected 0 events for conv-1, got %d", len(events))+ }++ events, err = log.Events(ctx, "conv-2")+ if err != nil {+ t.Fatalf("failed to read events: %v", err)+ }+ if len(events) != 1 {+ t.Errorf("expected 1 event for conv-2, got %d", len(events))+ }++ // Verify execution events+ eEvents, err := log.ExecEvents(ctx, "task-1")+ if err != nil {+ t.Fatalf("failed to read exec events: %v", err)+ }+ if len(eEvents) != 0 {+ t.Errorf("expected 0 exec events for task-1, got %d", len(eEvents))+ }++ eEvents, err = log.ExecEvents(ctx, "task-2")+ if err != nil {+ t.Fatalf("failed to read exec events: %v", err)+ }+ if len(eEvents) != 0 {+ t.Errorf("expected 0 exec events for task-2, got %d", len(eEvents))+ }++ eEvents, err = log.ExecEvents(ctx, "task-3")+ if err != nil {+ t.Fatalf("failed to read exec events: %v", err)+ }+ if len(eEvents) != 1 {+ t.Errorf("expected 1 exec event for task-3, got %d", len(eEvents))+ }+}+func TestSQLiteEventLog_CreatesParentDirectory(t *testing.T) {// Create a path with a non-existent parent directorydbPath := filepath.Join(t.TempDir(), "newdir", "test.db")diff --git a/internal/server/server.go b/internal/server/server.goindex d6c7319..0c876df 100644--- a/internal/server/server.go+++ b/internal/server/server.go@@ -34,6 +34,7 @@ import (// Server implements the AXService gRPC service.type Server struct {proto.UnimplementedAXServiceServer+ proto.UnimplementedAXEventLogServiceServercontroller *controller.ControllergrpcServer *grpc.Server@@ -56,7 +57,21 @@ func (s *Server) Exec(req *proto.ExecRequest, stream grpc.ServerStreamingServer[}func (s *Server) Fork(ctx context.Context, req *proto.ForkRequest) (*proto.ForkResponse, error) {- return nil, status.Errorf(codes.Unimplemented, "forking not implemented")+ return nil, status.Errorf(codes.Unimplemented, "not implemented")+}++func (s *Server) List(ctx context.Context, req *proto.ListRequest) (*proto.ListResponse, error) {+ return nil, status.Errorf(codes.Unimplemented, "not implemented")+}++func (s *Server) Delete(ctx context.Context, req *proto.DeleteRequest) (*proto.DeleteResponse, error) {+ if req.ConversationId == "" {+ return nil, status.Errorf(codes.InvalidArgument, "conversation_id is required")+ }+ if err := s.controller.Delete(ctx, req.ConversationId); err != nil {+ return nil, status.Errorf(codes.Internal, "failed to delete conversation: %v", err)+ }+ return &proto.DeleteResponse{}, nil}// RegisterAgent registers a new remote agent with the controller.@@ -110,6 +125,7 @@ func (s *Server) Serve(address string, opts ...grpc.ServerOption) error {s.grpcServer = grpc.NewServer(opts...)proto.RegisterAXServiceServer(s.grpcServer, s)+ proto.RegisterAXEventLogServiceServer(s.grpcServer, s)if err := s.grpcServer.Serve(lis); err != nil {return fmt.Errorf("failed to serve: %w", err)diff --git a/proto/ax.pb.go b/proto/ax.pb.goindex 3b4a70d..b8339d7 100644--- a/proto/ax.pb.go+++ b/proto/ax.pb.go@@ -1218,78 +1218,6 @@ func (x *ExecResponse) GetSeq() int32 {return 0}-type ForkRequest struct {- state protoimpl.MessageState `protogen:"open.v1"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache-}--func (x *ForkRequest) Reset() {- *x = ForkRequest{}- mi := &file_proto_ax_proto_msgTypes[17]- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- ms.StoreMessageInfo(mi)-}--func (x *ForkRequest) String() string {- return protoimpl.X.MessageStringOf(x)-}--func (*ForkRequest) ProtoMessage() {}--func (x *ForkRequest) ProtoReflect() protoreflect.Message {- mi := &file_proto_ax_proto_msgTypes[17]- if x != nil {- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- if ms.LoadMessageInfo() == nil {- ms.StoreMessageInfo(mi)- }- return ms- }- return mi.MessageOf(x)-}--// Deprecated: Use ForkRequest.ProtoReflect.Descriptor instead.-func (*ForkRequest) Descriptor() ([]byte, []int) {- return file_proto_ax_proto_rawDescGZIP(), []int{17}-}--type ForkResponse struct {- state protoimpl.MessageState `protogen:"open.v1"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache-}--func (x *ForkResponse) Reset() {- *x = ForkResponse{}- mi := &file_proto_ax_proto_msgTypes[18]- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- ms.StoreMessageInfo(mi)-}--func (x *ForkResponse) String() string {- return protoimpl.X.MessageStringOf(x)-}--func (*ForkResponse) ProtoMessage() {}--func (x *ForkResponse) ProtoReflect() protoreflect.Message {- mi := &file_proto_ax_proto_msgTypes[18]- if x != nil {- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- if ms.LoadMessageInfo() == nil {- ms.StoreMessageInfo(mi)- }- return ms- }- return mi.MessageOf(x)-}--// Deprecated: Use ForkResponse.ProtoReflect.Descriptor instead.-func (*ForkResponse) Descriptor() ([]byte, []int) {- return file_proto_ax_proto_rawDescGZIP(), []int{18}-}-type RemoteAgentConfig struct {state protoimpl.MessageState `protogen:"open.v1"`Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` // gRPC address for remote agents@@ -1299,7 +1227,7 @@ type RemoteAgentConfig struct {func (x *RemoteAgentConfig) Reset() {*x = RemoteAgentConfig{}- mi := &file_proto_ax_proto_msgTypes[19]+ mi := &file_proto_ax_proto_msgTypes[17]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1311,7 +1239,7 @@ func (x *RemoteAgentConfig) String() string {func (*RemoteAgentConfig) ProtoMessage() {}func (x *RemoteAgentConfig) ProtoReflect() protoreflect.Message {- mi := &file_proto_ax_proto_msgTypes[19]+ mi := &file_proto_ax_proto_msgTypes[17]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1324,7 +1252,7 @@ func (x *RemoteAgentConfig) ProtoReflect() protoreflect.Message {// Deprecated: Use RemoteAgentConfig.ProtoReflect.Descriptor instead.func (*RemoteAgentConfig) Descriptor() ([]byte, []int) {- return file_proto_ax_proto_rawDescGZIP(), []int{19}+ return file_proto_ax_proto_rawDescGZIP(), []int{17}}func (x *RemoteAgentConfig) GetAddress() string {@@ -1351,7 +1279,7 @@ type RegisterAgentRequest struct {func (x *RegisterAgentRequest) Reset() {*x = RegisterAgentRequest{}- mi := &file_proto_ax_proto_msgTypes[20]+ mi := &file_proto_ax_proto_msgTypes[18]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1363,7 +1291,7 @@ func (x *RegisterAgentRequest) String() string {func (*RegisterAgentRequest) ProtoMessage() {}func (x *RegisterAgentRequest) ProtoReflect() protoreflect.Message {- mi := &file_proto_ax_proto_msgTypes[20]+ mi := &file_proto_ax_proto_msgTypes[18]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1376,7 +1304,7 @@ func (x *RegisterAgentRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use RegisterAgentRequest.ProtoReflect.Descriptor instead.func (*RegisterAgentRequest) Descriptor() ([]byte, []int) {- return file_proto_ax_proto_rawDescGZIP(), []int{20}+ return file_proto_ax_proto_rawDescGZIP(), []int{18}}func (x *RegisterAgentRequest) GetAgentId() string {@@ -1443,7 +1371,7 @@ type RegisterAgentResponse struct {func (x *RegisterAgentResponse) Reset() {*x = RegisterAgentResponse{}- mi := &file_proto_ax_proto_msgTypes[21]+ mi := &file_proto_ax_proto_msgTypes[19]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1455,7 +1383,7 @@ func (x *RegisterAgentResponse) String() string {func (*RegisterAgentResponse) ProtoMessage() {}func (x *RegisterAgentResponse) ProtoReflect() protoreflect.Message {- mi := &file_proto_ax_proto_msgTypes[21]+ mi := &file_proto_ax_proto_msgTypes[19]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1468,7 +1396,7 @@ func (x *RegisterAgentResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use RegisterAgentResponse.ProtoReflect.Descriptor instead.func (*RegisterAgentResponse) Descriptor() ([]byte, []int) {- return file_proto_ax_proto_rawDescGZIP(), []int{21}+ return file_proto_ax_proto_rawDescGZIP(), []int{19}}func (x *RegisterAgentResponse) GetHealthy() bool {@@ -1478,6 +1406,246 @@ func (x *RegisterAgentResponse) GetHealthy() bool {return false}+type ListRequest struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ ConversationId string `protobuf:"bytes,1,opt,name=conversation_id,json=conversationId,proto3" json:"conversation_id,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *ListRequest) Reset() {+ *x = ListRequest{}+ mi := &file_proto_ax_proto_msgTypes[20]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *ListRequest) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*ListRequest) ProtoMessage() {}++func (x *ListRequest) ProtoReflect() protoreflect.Message {+ mi := &file_proto_ax_proto_msgTypes[20]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use ListRequest.ProtoReflect.Descriptor instead.+func (*ListRequest) Descriptor() ([]byte, []int) {+ return file_proto_ax_proto_rawDescGZIP(), []int{20}+}++func (x *ListRequest) GetConversationId() string {+ if x != nil {+ return x.ConversationId+ }+ return ""+}++type ListResponse struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ Events []*ConversationEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` // TODO: Do we need pagination?+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *ListResponse) Reset() {+ *x = ListResponse{}+ mi := &file_proto_ax_proto_msgTypes[21]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *ListResponse) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*ListResponse) ProtoMessage() {}++func (x *ListResponse) ProtoReflect() protoreflect.Message {+ mi := &file_proto_ax_proto_msgTypes[21]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use ListResponse.ProtoReflect.Descriptor instead.+func (*ListResponse) Descriptor() ([]byte, []int) {+ return file_proto_ax_proto_rawDescGZIP(), []int{21}+}++func (x *ListResponse) GetEvents() []*ConversationEvent {+ if x != nil {+ return x.Events+ }+ return nil+}++type DeleteRequest struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ ConversationId string `protobuf:"bytes,1,opt,name=conversation_id,json=conversationId,proto3" json:"conversation_id,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *DeleteRequest) Reset() {+ *x = DeleteRequest{}+ mi := &file_proto_ax_proto_msgTypes[22]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *DeleteRequest) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*DeleteRequest) ProtoMessage() {}++func (x *DeleteRequest) ProtoReflect() protoreflect.Message {+ mi := &file_proto_ax_proto_msgTypes[22]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use DeleteRequest.ProtoReflect.Descriptor instead.+func (*DeleteRequest) Descriptor() ([]byte, []int) {+ return file_proto_ax_proto_rawDescGZIP(), []int{22}+}++func (x *DeleteRequest) GetConversationId() string {+ if x != nil {+ return x.ConversationId+ }+ return ""+}++type DeleteResponse struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *DeleteResponse) Reset() {+ *x = DeleteResponse{}+ mi := &file_proto_ax_proto_msgTypes[23]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *DeleteResponse) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*DeleteResponse) ProtoMessage() {}++func (x *DeleteResponse) ProtoReflect() protoreflect.Message {+ mi := &file_proto_ax_proto_msgTypes[23]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use DeleteResponse.ProtoReflect.Descriptor instead.+func (*DeleteResponse) Descriptor() ([]byte, []int) {+ return file_proto_ax_proto_rawDescGZIP(), []int{23}+}++type ForkRequest struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *ForkRequest) Reset() {+ *x = ForkRequest{}+ mi := &file_proto_ax_proto_msgTypes[24]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *ForkRequest) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*ForkRequest) ProtoMessage() {}++func (x *ForkRequest) ProtoReflect() protoreflect.Message {+ mi := &file_proto_ax_proto_msgTypes[24]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use ForkRequest.ProtoReflect.Descriptor instead.+func (*ForkRequest) Descriptor() ([]byte, []int) {+ return file_proto_ax_proto_rawDescGZIP(), []int{24}+}++type ForkResponse struct {+ state protoimpl.MessageState `protogen:"open.v1"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache+}++func (x *ForkResponse) Reset() {+ *x = ForkResponse{}+ mi := &file_proto_ax_proto_msgTypes[25]+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ ms.StoreMessageInfo(mi)+}++func (x *ForkResponse) String() string {+ return protoimpl.X.MessageStringOf(x)+}++func (*ForkResponse) ProtoMessage() {}++func (x *ForkResponse) ProtoReflect() protoreflect.Message {+ mi := &file_proto_ax_proto_msgTypes[25]+ if x != nil {+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))+ if ms.LoadMessageInfo() == nil {+ ms.StoreMessageInfo(mi)+ }+ return ms+ }+ return mi.MessageOf(x)+}++// Deprecated: Use ForkResponse.ProtoReflect.Descriptor instead.+func (*ForkResponse) Descriptor() ([]byte, []int) {+ return file_proto_ax_proto_rawDescGZIP(), []int{25}+}+// GeminiConfig is the configuration for a Gemini agent.type GeminiConfig struct {state protoimpl.MessageState `protogen:"open.v1"`@@ -1492,7 +1660,7 @@ type GeminiConfig struct {func (x *GeminiConfig) Reset() {*x = GeminiConfig{}- mi := &file_proto_ax_proto_msgTypes[22]+ mi := &file_proto_ax_proto_msgTypes[26]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1504,7 +1672,7 @@ func (x *GeminiConfig) String() string {func (*GeminiConfig) ProtoMessage() {}func (x *GeminiConfig) ProtoReflect() protoreflect.Message {- mi := &file_proto_ax_proto_msgTypes[22]+ mi := &file_proto_ax_proto_msgTypes[26]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1517,7 +1685,7 @@ func (x *GeminiConfig) ProtoReflect() protoreflect.Message {// Deprecated: Use GeminiConfig.ProtoReflect.Descriptor instead.func (*GeminiConfig) Descriptor() ([]byte, []int) {- return file_proto_ax_proto_rawDescGZIP(), []int{22}+ return file_proto_ax_proto_rawDescGZIP(), []int{26}}func (x *GeminiConfig) GetModel() string {@@ -1632,9 +1800,7 @@ const file_proto_ax_proto_rawDesc = "" +"\fagent_config\x18\x05 \x01(\v2\x14.google.protobuf.AnyR\vagentConfig\"J\n" +"\fExecResponse\x12(\n" +"\aoutputs\x18\x01 \x03(\v2\x0e.proto.MessageR\aoutputs\x12\x10\n" +- "\x03seq\x18\x02 \x01(\x05R\x03seq\"\r\n" +- "\vForkRequest\"\x0e\n" +- "\fForkResponse\"-\n" ++ "\x03seq\x18\x02 \x01(\x05R\x03seq\"-\n" +"\x11RemoteAgentConfig\x12\x18\n" +"\aaddress\x18\x01 \x01(\tR\aaddress\"\xa9\x02\n" +"\x14RegisterAgentRequest\x12\x19\n" +@@ -1648,7 +1814,16 @@ const file_proto_ax_proto_rawDesc = "" +"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\b\n" +"\x06config\"1\n" +"\x15RegisterAgentResponse\x12\x18\n" +- "\ahealthy\x18\x01 \x01(\bR\ahealthy\"\xb3\x01\n" ++ "\ahealthy\x18\x01 \x01(\bR\ahealthy\"6\n" ++ "\vListRequest\x12'\n" ++ "\x0fconversation_id\x18\x01 \x01(\tR\x0econversationId\"@\n" ++ "\fListResponse\x120\n" ++ "\x06events\x18\x01 \x03(\v2\x18.proto.ConversationEventR\x06events\"8\n" ++ "\rDeleteRequest\x12'\n" ++ "\x0fconversation_id\x18\x01 \x01(\tR\x0econversationId\"\x10\n" ++ "\x0eDeleteResponse\"\r\n" ++ "\vForkRequest\"\x0e\n" ++ "\fForkResponse\"\xb3\x01\n" +"\fGeminiConfig\x12\x14\n" +"\x05model\x18\x01 \x01(\tR\x05model\x12#\n" +"\rsystem_prompt\x18\x02 \x01(\tR\fsystemPrompt\x12\x1d\n" +@@ -1663,11 +1838,14 @@ const file_proto_ax_proto_rawDesc = "" +"\x0fSTATE_COMPLETED\x10\x032\x8f\x01\n" +"\x0eAXAgentService\x127\n" +"\aConnect\x12\x13.proto.AgentMessage\x1a\x13.proto.AgentMessage(\x010\x01\x12D\n" +- "\vHealthCheck\x12\x19.proto.HealthCheckRequest\x1a\x1a.proto.HealthCheckResponse2\xbb\x01\n" ++ "\vHealthCheck\x12\x19.proto.HealthCheckRequest\x1a\x1a.proto.HealthCheckResponse2\x8a\x01\n" +"\tAXService\x121\n" +- "\x04Exec\x12\x12.proto.ExecRequest\x1a\x13.proto.ExecResponse0\x01\x12/\n" +- "\x04Fork\x12\x12.proto.ForkRequest\x1a\x13.proto.ForkResponse\x12J\n" +- "\rRegisterAgent\x12\x1b.proto.RegisterAgentRequest\x1a\x1c.proto.RegisterAgentResponseB\x1cZ\x1agithub.com/google/ax/protob\x06proto3"+ "\x04Exec\x12\x12.proto.ExecRequest\x1a\x13.proto.ExecResponse0\x01\x12J\n" ++ "\rRegisterAgent\x12\x1b.proto.RegisterAgentRequest\x1a\x1c.proto.RegisterAgentResponse2\xac\x01\n" ++ "\x11AXEventLogService\x12/\n" ++ "\x04List\x12\x12.proto.ListRequest\x1a\x13.proto.ListResponse\x125\n" ++ "\x06Delete\x12\x14.proto.DeleteRequest\x1a\x15.proto.DeleteResponse\x12/\n" ++ "\x04Fork\x12\x12.proto.ForkRequest\x1a\x13.proto.ForkResponseB\x1cZ\x1agithub.com/google/ax/protob\x06proto3"var (file_proto_ax_proto_rawDescOnce sync.Once@@ -1682,7 +1860,7 @@ func file_proto_ax_proto_rawDescGZIP() []byte {}var file_proto_ax_proto_enumTypes = make([]protoimpl.EnumInfo, 1)-var file_proto_ax_proto_msgTypes = make([]protoimpl.MessageInfo, 24)+var file_proto_ax_proto_msgTypes = make([]protoimpl.MessageInfo, 28)var file_proto_ax_proto_goTypes = []any{(State)(0), // 0: proto.State(*AgentStart)(nil), // 1: proto.AgentStart@@ -1702,28 +1880,32 @@ var file_proto_ax_proto_goTypes = []any{(*HealthCheckResponse)(nil), // 15: proto.HealthCheckResponse(*ExecRequest)(nil), // 16: proto.ExecRequest(*ExecResponse)(nil), // 17: proto.ExecResponse- (*ForkRequest)(nil), // 18: proto.ForkRequest- (*ForkResponse)(nil), // 19: proto.ForkResponse- (*RemoteAgentConfig)(nil), // 20: proto.RemoteAgentConfig- (*RegisterAgentRequest)(nil), // 21: proto.RegisterAgentRequest- (*RegisterAgentResponse)(nil), // 22: proto.RegisterAgentResponse- (*GeminiConfig)(nil), // 23: proto.GeminiConfig- nil, // 24: proto.RegisterAgentRequest.MetadataEntry- (*anypb.Any)(nil), // 25: google.protobuf.Any- (*structpb.Struct)(nil), // 26: google.protobuf.Struct- (*timestamppb.Timestamp)(nil), // 27: google.protobuf.Timestamp- (*durationpb.Duration)(nil), // 28: google.protobuf.Duration+ (*RemoteAgentConfig)(nil), // 18: proto.RemoteAgentConfig+ (*RegisterAgentRequest)(nil), // 19: proto.RegisterAgentRequest+ (*RegisterAgentResponse)(nil), // 20: proto.RegisterAgentResponse+ (*ListRequest)(nil), // 21: proto.ListRequest+ (*ListResponse)(nil), // 22: proto.ListResponse+ (*DeleteRequest)(nil), // 23: proto.DeleteRequest+ (*DeleteResponse)(nil), // 24: proto.DeleteResponse+ (*ForkRequest)(nil), // 25: proto.ForkRequest+ (*ForkResponse)(nil), // 26: proto.ForkResponse+ (*GeminiConfig)(nil), // 27: proto.GeminiConfig+ nil, // 28: proto.RegisterAgentRequest.MetadataEntry+ (*anypb.Any)(nil), // 29: google.protobuf.Any+ (*structpb.Struct)(nil), // 30: google.protobuf.Struct+ (*timestamppb.Timestamp)(nil), // 31: google.protobuf.Timestamp+ (*durationpb.Duration)(nil), // 32: google.protobuf.Duration}var file_proto_ax_proto_depIdxs = []int32{- 25, // 0: proto.AgentStart.config:type_name -> google.protobuf.Any+ 29, // 0: proto.AgentStart.config:type_name -> google.protobuf.Any11, // 1: proto.AgentStart.messages:type_name -> proto.Message11, // 2: proto.AgentOutputs.messages:type_name -> proto.Message1, // 3: proto.AgentMessage.start:type_name -> proto.AgentStart2, // 4: proto.AgentMessage.outputs:type_name -> proto.AgentOutputs5, // 5: proto.ConfirmationContent.approval:type_name -> proto.ApprovalDecision6, // 6: proto.ConfirmationContent.decline:type_name -> proto.DeclineDecision- 26, // 7: proto.FunctionCallContent.args:type_name -> google.protobuf.Struct- 26, // 8: proto.FunctionResponseContent.response:type_name -> google.protobuf.Struct+ 30, // 7: proto.FunctionCallContent.args:type_name -> google.protobuf.Struct+ 30, // 8: proto.FunctionResponseContent.response:type_name -> google.protobuf.Struct4, // 9: proto.Content.text:type_name -> proto.TextContent7, // 10: proto.Content.confirmation:type_name -> proto.ConfirmationContent8, // 11: proto.Content.function_call:type_name -> proto.FunctionCallContent@@ -1731,32 +1913,37 @@ var file_proto_ax_proto_depIdxs = []int32{10, // 13: proto.Message.content:type_name -> proto.Content11, // 14: proto.ConversationEvent.messages:type_name -> proto.Message0, // 15: proto.ConversationEvent.state:type_name -> proto.State- 25, // 16: proto.ExecutionEvent.agent_config:type_name -> google.protobuf.Any+ 29, // 16: proto.ExecutionEvent.agent_config:type_name -> google.protobuf.Any11, // 17: proto.ExecutionEvent.inputs:type_name -> proto.Message11, // 18: proto.ExecutionEvent.outputs:type_name -> proto.Message0, // 19: proto.ExecutionEvent.state:type_name -> proto.State- 27, // 20: proto.ExecutionEvent.timestamp:type_name -> google.protobuf.Timestamp+ 31, // 20: proto.ExecutionEvent.timestamp:type_name -> google.protobuf.Timestamp11, // 21: proto.ExecRequest.inputs:type_name -> proto.Message- 25, // 22: proto.ExecRequest.agent_config:type_name -> google.protobuf.Any+ 29, // 22: proto.ExecRequest.agent_config:type_name -> google.protobuf.Any11, // 23: proto.ExecResponse.outputs:type_name -> proto.Message- 24, // 24: proto.RegisterAgentRequest.metadata:type_name -> proto.RegisterAgentRequest.MetadataEntry- 20, // 25: proto.RegisterAgentRequest.remote:type_name -> proto.RemoteAgentConfig- 28, // 26: proto.GeminiConfig.timeout:type_name -> google.protobuf.Duration- 3, // 27: proto.AXAgentService.Connect:input_type -> proto.AgentMessage- 14, // 28: proto.AXAgentService.HealthCheck:input_type -> proto.HealthCheckRequest- 16, // 29: proto.AXService.Exec:input_type -> proto.ExecRequest- 18, // 30: proto.AXService.Fork:input_type -> proto.ForkRequest- 21, // 31: proto.AXService.RegisterAgent:input_type -> proto.RegisterAgentRequest- 3, // 32: proto.AXAgentService.Connect:output_type -> proto.AgentMessage- 15, // 33: proto.AXAgentService.HealthCheck:output_type -> proto.HealthCheckResponse- 17, // 34: proto.AXService.Exec:output_type -> proto.ExecResponse- 19, // 35: proto.AXService.Fork:output_type -> proto.ForkResponse- 22, // 36: proto.AXService.RegisterAgent:output_type -> proto.RegisterAgentResponse- 32, // [32:37] is the sub-list for method output_type- 27, // [27:32] is the sub-list for method input_type- 27, // [27:27] is the sub-list for extension type_name- 27, // [27:27] is the sub-list for extension extendee- 0, // [0:27] is the sub-list for field type_name+ 28, // 24: proto.RegisterAgentRequest.metadata:type_name -> proto.RegisterAgentRequest.MetadataEntry+ 18, // 25: proto.RegisterAgentRequest.remote:type_name -> proto.RemoteAgentConfig+ 12, // 26: proto.ListResponse.events:type_name -> proto.ConversationEvent+ 32, // 27: proto.GeminiConfig.timeout:type_name -> google.protobuf.Duration+ 3, // 28: proto.AXAgentService.Connect:input_type -> proto.AgentMessage+ 14, // 29: proto.AXAgentService.HealthCheck:input_type -> proto.HealthCheckRequest+ 16, // 30: proto.AXService.Exec:input_type -> proto.ExecRequest+ 19, // 31: proto.AXService.RegisterAgent:input_type -> proto.RegisterAgentRequest+ 21, // 32: proto.AXEventLogService.List:input_type -> proto.ListRequest+ 23, // 33: proto.AXEventLogService.Delete:input_type -> proto.DeleteRequest+ 25, // 34: proto.AXEventLogService.Fork:input_type -> proto.ForkRequest+ 3, // 35: proto.AXAgentService.Connect:output_type -> proto.AgentMessage+ 15, // 36: proto.AXAgentService.HealthCheck:output_type -> proto.HealthCheckResponse+ 17, // 37: proto.AXService.Exec:output_type -> proto.ExecResponse+ 20, // 38: proto.AXService.RegisterAgent:output_type -> proto.RegisterAgentResponse+ 22, // 39: proto.AXEventLogService.List:output_type -> proto.ListResponse+ 24, // 40: proto.AXEventLogService.Delete:output_type -> proto.DeleteResponse+ 26, // 41: proto.AXEventLogService.Fork:output_type -> proto.ForkResponse+ 35, // [35:42] is the sub-list for method output_type+ 28, // [28:35] is the sub-list for method input_type+ 28, // [28:28] is the sub-list for extension type_name+ 28, // [28:28] is the sub-list for extension extendee+ 0, // [0:28] is the sub-list for field type_name}func init() { file_proto_ax_proto_init() }@@ -1778,7 +1965,7 @@ func file_proto_ax_proto_init() {(*Content_FunctionCall)(nil),(*Content_FunctionResponse)(nil),}- file_proto_ax_proto_msgTypes[20].OneofWrappers = []any{+ file_proto_ax_proto_msgTypes[18].OneofWrappers = []any{(*RegisterAgentRequest_Remote)(nil),}type x struct{}@@ -1787,9 +1974,9 @@ func file_proto_ax_proto_init() {GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_ax_proto_rawDesc), len(file_proto_ax_proto_rawDesc)),NumEnums: 1,- NumMessages: 24,+ NumMessages: 28,NumExtensions: 0,- NumServices: 2,+ NumServices: 3,},GoTypes: file_proto_ax_proto_goTypes,DependencyIndexes: file_proto_ax_proto_depIdxs,diff --git a/proto/ax.proto b/proto/ax.protoindex 6d0d86b..91ac2da 100644--- a/proto/ax.proto+++ b/proto/ax.proto@@ -177,12 +177,6 @@ message ExecResponse {int32 seq = 2; // Seq of the outputs}-message ForkRequest {-}--message ForkResponse {-}-message RemoteAgentConfig {string address = 1; // gRPC address for remote agents}@@ -209,13 +203,41 @@ service AXService {// If the conversation_id already exists, it will be resumed.rpc Exec(ExecRequest) returns (stream ExecResponse);- // Fork forks an event log from a specific conversation.- rpc Fork(ForkRequest) returns (ForkResponse);-// RegisterAgent registers a new agent with the controllerrpc RegisterAgent(RegisterAgentRequest) returns (RegisterAgentResponse);}+message ListRequest {+ string conversation_id = 1;+}++message ListResponse {+ repeated ConversationEvent events = 1;+ // TODO: Do we need pagination?+}++message DeleteRequest {+ string conversation_id = 1;+}++message DeleteResponse {}++message ForkRequest {}++message ForkResponse {}++service AXEventLogService {+ // List conversational events.+ rpc List(ListRequest) returns (ListResponse);++ // Deletes conversational events and all event log resources+ // for its children executions.+ rpc Delete(DeleteRequest) returns (DeleteResponse);++ // Fork forks an event log from a specific conversation.+ rpc Fork(ForkRequest) returns (ForkResponse);+}+// GeminiConfig is the configuration for a Gemini agent.message GeminiConfig {string model = 1; // e.g. "gemini-3-flash-preview"diff --git a/proto/ax_grpc.pb.go b/proto/ax_grpc.pb.goindex a219543..c018cdf 100644--- a/proto/ax_grpc.pb.go+++ b/proto/ax_grpc.pb.go@@ -177,7 +177,6 @@ var AXAgentService_ServiceDesc = grpc.ServiceDesc{const (AXService_Exec_FullMethodName = "/proto.AXService/Exec"- AXService_Fork_FullMethodName = "/proto.AXService/Fork"AXService_RegisterAgent_FullMethodName = "/proto.AXService/RegisterAgent")@@ -190,8 +189,6 @@ type AXServiceClient interface {// Exec executes an agentic task or resumes an existing one with streaming responses// If the conversation_id already exists, it will be resumed.Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ExecResponse], error)- // Fork forks an event log from a specific conversation.- Fork(ctx context.Context, in *ForkRequest, opts ...grpc.CallOption) (*ForkResponse, error)// RegisterAgent registers a new agent with the controllerRegisterAgent(ctx context.Context, in *RegisterAgentRequest, opts ...grpc.CallOption) (*RegisterAgentResponse, error)}@@ -223,16 +220,6 @@ func (c *aXServiceClient) Exec(ctx context.Context, in *ExecRequest, opts ...grp// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.type AXService_ExecClient = grpc.ServerStreamingClient[ExecResponse]-func (c *aXServiceClient) Fork(ctx context.Context, in *ForkRequest, opts ...grpc.CallOption) (*ForkResponse, error) {- cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)- out := new(ForkResponse)- err := c.cc.Invoke(ctx, AXService_Fork_FullMethodName, in, out, cOpts...)- if err != nil {- return nil, err- }- return out, nil-}-func (c *aXServiceClient) RegisterAgent(ctx context.Context, in *RegisterAgentRequest, opts ...grpc.CallOption) (*RegisterAgentResponse, error) {cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)out := new(RegisterAgentResponse)@@ -252,8 +239,6 @@ type AXServiceServer interface {// Exec executes an agentic task or resumes an existing one with streaming responses// If the conversation_id already exists, it will be resumed.Exec(*ExecRequest, grpc.ServerStreamingServer[ExecResponse]) error- // Fork forks an event log from a specific conversation.- Fork(context.Context, *ForkRequest) (*ForkResponse, error)// RegisterAgent registers a new agent with the controllerRegisterAgent(context.Context, *RegisterAgentRequest) (*RegisterAgentResponse, error)mustEmbedUnimplementedAXServiceServer()@@ -269,9 +254,6 @@ type UnimplementedAXServiceServer struct{}func (UnimplementedAXServiceServer) Exec(*ExecRequest, grpc.ServerStreamingServer[ExecResponse]) error {return status.Errorf(codes.Unimplemented, "method Exec not implemented")}-func (UnimplementedAXServiceServer) Fork(context.Context, *ForkRequest) (*ForkResponse, error) {- return nil, status.Errorf(codes.Unimplemented, "method Fork not implemented")-}func (UnimplementedAXServiceServer) RegisterAgent(context.Context, *RegisterAgentRequest) (*RegisterAgentResponse, error) {return nil, status.Errorf(codes.Unimplemented, "method RegisterAgent not implemented")}@@ -307,24 +289,6 @@ func _AXService_Exec_Handler(srv interface{}, stream grpc.ServerStream) error {// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.type AXService_ExecServer = grpc.ServerStreamingServer[ExecResponse]-func _AXService_Fork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {- in := new(ForkRequest)- if err := dec(in); err != nil {- return nil, err- }- if interceptor == nil {- return srv.(AXServiceServer).Fork(ctx, in)- }- info := &grpc.UnaryServerInfo{- Server: srv,- FullMethod: AXService_Fork_FullMethodName,- }- handler := func(ctx context.Context, req interface{}) (interface{}, error) {- return srv.(AXServiceServer).Fork(ctx, req.(*ForkRequest))- }- return interceptor(ctx, in, info, handler)-}-func _AXService_RegisterAgent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {in := new(RegisterAgentRequest)if err := dec(in); err != nil {@@ -350,10 +314,6 @@ var AXService_ServiceDesc = grpc.ServiceDesc{ServiceName: "proto.AXService",HandlerType: (*AXServiceServer)(nil),Methods: []grpc.MethodDesc{- {- MethodName: "Fork",- Handler: _AXService_Fork_Handler,- },{MethodName: "RegisterAgent",Handler: _AXService_RegisterAgent_Handler,@@ -368,3 +328,189 @@ var AXService_ServiceDesc = grpc.ServiceDesc{},Metadata: "proto/ax.proto",}++const (+ AXEventLogService_List_FullMethodName = "/proto.AXEventLogService/List"+ AXEventLogService_Delete_FullMethodName = "/proto.AXEventLogService/Delete"+ AXEventLogService_Fork_FullMethodName = "/proto.AXEventLogService/Fork"+)++// AXEventLogServiceClient is the client API for AXEventLogService service.+//+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.+type AXEventLogServiceClient interface {+ // List conversational events.+ List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)+ // Deletes conversational events and all event log resources+ // for its children executions.+ Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error)+ // Fork forks an event log from a specific conversation.+ Fork(ctx context.Context, in *ForkRequest, opts ...grpc.CallOption) (*ForkResponse, error)+}++type aXEventLogServiceClient struct {+ cc grpc.ClientConnInterface+}++func NewAXEventLogServiceClient(cc grpc.ClientConnInterface) AXEventLogServiceClient {+ return &aXEventLogServiceClient{cc}+}++func (c *aXEventLogServiceClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {+ cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)+ out := new(ListResponse)+ err := c.cc.Invoke(ctx, AXEventLogService_List_FullMethodName, in, out, cOpts...)+ if err != nil {+ return nil, err+ }+ return out, nil+}++func (c *aXEventLogServiceClient) Delete(ctx context.Context, in *DeleteRequest, opts ...grpc.CallOption) (*DeleteResponse, error) {+ cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)+ out := new(DeleteResponse)+ err := c.cc.Invoke(ctx, AXEventLogService_Delete_FullMethodName, in, out, cOpts...)+ if err != nil {+ return nil, err+ }+ return out, nil+}++func (c *aXEventLogServiceClient) Fork(ctx context.Context, in *ForkRequest, opts ...grpc.CallOption) (*ForkResponse, error) {+ cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)+ out := new(ForkResponse)+ err := c.cc.Invoke(ctx, AXEventLogService_Fork_FullMethodName, in, out, cOpts...)+ if err != nil {+ return nil, err+ }+ return out, nil+}++// AXEventLogServiceServer is the server API for AXEventLogService service.+// All implementations must embed UnimplementedAXEventLogServiceServer+// for forward compatibility.+type AXEventLogServiceServer interface {+ // List conversational events.+ List(context.Context, *ListRequest) (*ListResponse, error)+ // Deletes conversational events and all event log resources+ // for its children executions.+ Delete(context.Context, *DeleteRequest) (*DeleteResponse, error)+ // Fork forks an event log from a specific conversation.+ Fork(context.Context, *ForkRequest) (*ForkResponse, error)+ mustEmbedUnimplementedAXEventLogServiceServer()+}++// UnimplementedAXEventLogServiceServer must be embedded to have+// forward compatible implementations.+//+// NOTE: this should be embedded by value instead of pointer to avoid a nil+// pointer dereference when methods are called.+type UnimplementedAXEventLogServiceServer struct{}++func (UnimplementedAXEventLogServiceServer) List(context.Context, *ListRequest) (*ListResponse, error) {+ return nil, status.Errorf(codes.Unimplemented, "method List not implemented")+}+func (UnimplementedAXEventLogServiceServer) Delete(context.Context, *DeleteRequest) (*DeleteResponse, error) {+ return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")+}+func (UnimplementedAXEventLogServiceServer) Fork(context.Context, *ForkRequest) (*ForkResponse, error) {+ return nil, status.Errorf(codes.Unimplemented, "method Fork not implemented")+}+func (UnimplementedAXEventLogServiceServer) mustEmbedUnimplementedAXEventLogServiceServer() {}+func (UnimplementedAXEventLogServiceServer) testEmbeddedByValue() {}++// UnsafeAXEventLogServiceServer may be embedded to opt out of forward compatibility for this service.+// Use of this interface is not recommended, as added methods to AXEventLogServiceServer will+// result in compilation errors.+type UnsafeAXEventLogServiceServer interface {+ mustEmbedUnimplementedAXEventLogServiceServer()+}++func RegisterAXEventLogServiceServer(s grpc.ServiceRegistrar, srv AXEventLogServiceServer) {+ // If the following call pancis, it indicates UnimplementedAXEventLogServiceServer was+ // embedded by pointer and is nil. This will cause panics if an+ // unimplemented method is ever invoked, so we test this at initialization+ // time to prevent it from happening at runtime later due to I/O.+ if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {+ t.testEmbeddedByValue()+ }+ s.RegisterService(&AXEventLogService_ServiceDesc, srv)+}++func _AXEventLogService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {+ in := new(ListRequest)+ if err := dec(in); err != nil {+ return nil, err+ }+ if interceptor == nil {+ return srv.(AXEventLogServiceServer).List(ctx, in)+ }+ info := &grpc.UnaryServerInfo{+ Server: srv,+ FullMethod: AXEventLogService_List_FullMethodName,+ }+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {+ return srv.(AXEventLogServiceServer).List(ctx, req.(*ListRequest))+ }+ return interceptor(ctx, in, info, handler)+}++func _AXEventLogService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {+ in := new(DeleteRequest)+ if err := dec(in); err != nil {+ return nil, err+ }+ if interceptor == nil {+ return srv.(AXEventLogServiceServer).Delete(ctx, in)+ }+ info := &grpc.UnaryServerInfo{+ Server: srv,+ FullMethod: AXEventLogService_Delete_FullMethodName,+ }+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {+ return srv.(AXEventLogServiceServer).Delete(ctx, req.(*DeleteRequest))+ }+ return interceptor(ctx, in, info, handler)+}++func _AXEventLogService_Fork_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {+ in := new(ForkRequest)+ if err := dec(in); err != nil {+ return nil, err+ }+ if interceptor == nil {+ return srv.(AXEventLogServiceServer).Fork(ctx, in)+ }+ info := &grpc.UnaryServerInfo{+ Server: srv,+ FullMethod: AXEventLogService_Fork_FullMethodName,+ }+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {+ return srv.(AXEventLogServiceServer).Fork(ctx, req.(*ForkRequest))+ }+ return interceptor(ctx, in, info, handler)+}++// AXEventLogService_ServiceDesc is the grpc.ServiceDesc for AXEventLogService service.+// It's only intended for direct use with grpc.RegisterService,+// and not to be introspected or modified (even as a copy)+var AXEventLogService_ServiceDesc = grpc.ServiceDesc{+ ServiceName: "proto.AXEventLogService",+ HandlerType: (*AXEventLogServiceServer)(nil),+ Methods: []grpc.MethodDesc{+ {+ MethodName: "List",+ Handler: _AXEventLogService_List_Handler,+ },+ {+ MethodName: "Delete",+ Handler: _AXEventLogService_Delete_Handler,+ },+ {+ MethodName: "Fork",+ Handler: _AXEventLogService_Fork_Handler,+ },+ },+ Streams: []grpc.StreamDesc{},+ Metadata: "proto/ax.proto",+}