Skip to content

armgit / ax

Public Imported from GitHub
0

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.go
index 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, execID
return 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.go
index 9c732d3..5a34caf 100644
--- a/internal/controller/controller_test.go
+++ b/internal/controller/controller_test.go
@@ -16,58 +16,14 @@ package controller
import (
"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].ExecId
if 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_PENDING
err = 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].ExecId
if 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_COMPLETED
err = 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].ExecId
if 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].Outputs
if 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.go
index 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.go
index 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.go
new file mode 100644
index 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.go
index 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) ([]*prot
return 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.go
index 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 directory
dbPath := filepath.Join(t.TempDir(), "newdir", "test.db")
diff --git a/internal/server/server.go b/internal/server/server.go
index 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.UnimplementedAXEventLogServiceServer
controller *controller.Controller
grpcServer *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.go
index 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.Any
11, // 1: proto.AgentStart.messages:type_name -> proto.Message
11, // 2: proto.AgentOutputs.messages:type_name -> proto.Message
1, // 3: proto.AgentMessage.start:type_name -> proto.AgentStart
2, // 4: proto.AgentMessage.outputs:type_name -> proto.AgentOutputs
5, // 5: proto.ConfirmationContent.approval:type_name -> proto.ApprovalDecision
6, // 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.Struct
4, // 9: proto.Content.text:type_name -> proto.TextContent
7, // 10: proto.Content.confirmation:type_name -> proto.ConfirmationContent
8, // 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.Content
11, // 14: proto.ConversationEvent.messages:type_name -> proto.Message
0, // 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.Any
11, // 17: proto.ExecutionEvent.inputs:type_name -> proto.Message
11, // 18: proto.ExecutionEvent.outputs:type_name -> proto.Message
0, // 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.Timestamp
11, // 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.Any
11, // 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.proto
index 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 controller
rpc 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.go
index 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 controller
RegisterAgent(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 controller
RegisterAgent(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",
+}