package staterpc import ( "context" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" pb "github.com/samcharles93/archie-core/internal/contracts/state/v1" "github.com/samcharles93/archie-core/internal/domain/org" "github.com/samcharles93/archie-core/internal/domain/usage" "github.com/samcharles93/archie-core/internal/domain/workflow/task" "github.com/samcharles93/archie-core/internal/events" "github.com/samcharles93/archie-core/internal/taskstate" ) type executionServer struct { pb.UnimplementedExecutionServiceServer *server } // StartStep and FinishStep write a step transition and return its event. func (s *executionServer) StartStep(ctx context.Context, r *pb.StartStepRequest) (*pb.StartStepResponse, error) { if s.deps.Steps == nil { return nil, status.Error(codes.Unavailable, "step recorder unavailable") } stepID, event, err := s.deps.Steps.StartStep(ctx, task.StepStart{ ExecutionID: r.ExecutionId, Attempt: int(r.Attempt), ParentID: r.ParentId, Kind: r.Kind, Name: r.Name, CalledExecutionID: r.CalledExecutionId, }) if err != nil { return nil, s.logErr("StartStep", err) } return &pb.StartStepResponse{StepId: stepID, Event: eventProto(event)}, nil } // RecordUsage appends one model call's usage record. func (s *executionServer) RecordUsage(ctx context.Context, r *pb.RecordUsageRequest) (*pb.RecordUsageResponse, error) { if s.deps.Usage == nil { return nil, status.Error(codes.Unavailable, "usage recorder unavailable") } if r.Record == nil { return nil, status.Error(codes.InvalidArgument, "record is required") } record := usageValue(r.Record) // The caller never names the org: a task's is its row's, which the store // applies; anything else is the calling principal's. record.Org = string(org.OrgFromContext(ctx)) if err := s.deps.Usage.RecordUsage(ctx, record); err != nil { return nil, s.logErr("RecordUsage", err) } return &pb.RecordUsageResponse{}, nil } // CancelExecution is the one cancel path: // the store records the cancellation and returns the callees it cancelled // with it; the caller delivers it by cancelling the runs' in-memory contexts // afterwards. func (s *executionServer) CancelExecution(ctx context.Context, r *pb.CancelExecutionRequest) (*pb.CancelExecutionResponse, error) { if s.deps.Canceller == nil { return nil, status.Error(codes.Unavailable, "execution canceller unavailable") } ids, err := s.deps.Canceller.CancelExecution(ctx, r.TaskId, r.Reason, r.To) if err != nil { return nil, s.logErr("CancelExecution", err) } return &pb.CancelExecutionResponse{CancelledCalleeIds: ids}, nil } func (s *executionServer) FinishStep(ctx context.Context, r *pb.FinishStepRequest) (*pb.FinishStepResponse, error) { if s.deps.Steps == nil { return nil, status.Error(codes.Unavailable, "step recorder unavailable") } event, err := s.deps.Steps.FinishStep(ctx, task.StepFinish{ StepID: r.StepId, ExecutionID: r.ExecutionId, From: taskstate.StepStatus(r.From), To: taskstate.StepStatus(r.To), Detail: r.Detail, TokensUsed: r.TokensUsed, Results: r.Results, }) if err != nil { return nil, s.logErr("FinishStep", err) } return &pb.FinishStepResponse{Event: eventProto(event)}, nil } func (s *executionServer) ListSteps(ctx context.Context, r *pb.ListStepsRequest) (*pb.ListStepsResponse, error) { if s.deps.StepReader == nil { return nil, status.Error(codes.Unavailable, "step reader unavailable") } steps, err := s.deps.StepReader.ListSteps(ctx, r.ExecutionId, int(r.Attempt)) if err != nil { return nil, s.logErr("ListSteps", err) } return &pb.ListStepsResponse{Steps: mapValues(steps, stepExecutionProto)}, nil } // RecordUsage appends one model call's usage record. func (c *Client) RecordUsage(ctx context.Context, r usage.Record) error { _, err := c.execution.RecordUsage(ctx, &pb.RecordUsageRequest{Record: usageProto(r)}) return unmapError(err) } // StartStep and FinishStep record step executions and return the persisted // event. func (c *Client) StartStep(ctx context.Context, s task.StepStart) (int64, events.Event, error) { r, err := c.execution.StartStep(ctx, &pb.StartStepRequest{ ExecutionId: s.ExecutionID, Attempt: int64(s.Attempt), ParentId: s.ParentID, Kind: s.Kind, Name: s.Name, CalledExecutionId: s.CalledExecutionID, }) if err != nil { return 0, events.Event{}, unmapError(err) } event := events.Event{} if r.Event != nil { event = eventValue(r.Event) } return r.StepId, event, nil } // CancelExecution is the one cancel path: // the State Store records the cancellation -- every non-terminal step of the // current attempt plus the execution's own move, and its waited-on callees -- // and returns the callees it cancelled; the caller cancels the runs' // in-memory contexts afterwards. func (c *Client) CancelExecution(ctx context.Context, taskID int64, reason, to string) ([]int64, error) { r, err := c.execution.CancelExecution(ctx, &pb.CancelExecutionRequest{TaskId: taskID, Reason: reason, To: to}) if err != nil { return nil, unmapError(err) } return r.CancelledCalleeIds, nil } func (c *Client) FinishStep(ctx context.Context, s task.StepFinish) (events.Event, error) { r, err := c.execution.FinishStep(ctx, &pb.FinishStepRequest{ ExecutionId: s.ExecutionID, StepId: s.StepID, From: string(s.From), To: string(s.To), Detail: s.Detail, TokensUsed: s.TokensUsed, Results: s.Results, }) if err != nil { return events.Event{}, unmapError(err) } event := events.Event{} if r.Event != nil { event = eventValue(r.Event) } return event, nil } func (c *Client) ListSteps(ctx context.Context, executionID int64, attempt int) ([]task.StepExecution, error) { r, err := c.execution.ListSteps(ctx, &pb.ListStepsRequest{ExecutionId: executionID, Attempt: int64(attempt)}) if err != nil { return nil, unmapError(err) } steps := make([]task.StepExecution, len(r.Steps)) for i, s := range r.Steps { steps[i] = stepExecutionValue(s) } return steps, nil }