Function TestController_Exec_InternalOnly

internal/controller/controller_test.go:361–496

(t *testing.T)

}

func TestController_Exec_InternalOnly(t *testing.T) {
	ctx := context.Background()
	cid := "test-conv-internal"

	log := &executortest.MemoryEventLog{}

	// Create an agent that emits one internal-only message and one regular message.
	a := &mockAgentFunc{
		connectFunc: func(ctx context.Context, conversationID string, execID string, start *proto.AgentStart, e agent.Executor, o agent.OutputHandler) error {
			// If we already have the public message in history, don't emit anything.
			for _, m := range start.Messages {
				if m.GetContent().GetText().GetText() == "public message" {
					return nil
				}
			}
			// Emit internal-only message
			if err := o(&proto.AgentOutputs{
				Messages: []*proto.Message{
					{
						Role:         "assistant",
						InternalOnly: true,
						Content:      &proto.Content{Type: &proto.Content_Text{Text: &proto.TextContent{Text: "internal message"}}},
					},
				},
			}); err != nil {
				return err
			}
			// Emit regular message
			return o(&proto.AgentOutputs{
				Messages: []*proto.Message{
					{Role: "assistant", Content: &proto.Content{Type: &proto.Content_Text{Text: &proto.TextContent{Text: "public message"}}}},
				},
			})
		},
	}

	c, err := New(ctx, Config{
		EventLogBuilder: func() (executor.EventLog, error) {
			return log, nil
		},
		PlannerBuilder: func(ctx context.Context, r *Registry) (agent.Agent, error) {
			return a, nil
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	defer c.Close()

	var msgs []*proto.Message
	handler := ExecHandler(func(resp *proto.ExecResponse) error {
		msgs = append(msgs, resp.Outputs...)
		return nil
	})

	err = c.Exec(ctx, &proto.ExecRequest{
		ConversationId: cid,
		Inputs: []*proto.Message{