agent-radar
2ed3415fb7
Publish Claude Code Binaries / Stage and publish binaries (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-arm64 (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build linux-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build windows-amd64 (push) Canceled after 0s
Sync Tutti Agent Skills / sync (push) Canceled after 0s
Windows Agent Adapters / Test Windows agent adapters (push) Canceled after 0s
Windows Daemon Adapters / Test Windows daemon adapters (push) Canceled after 0s
Publish Tutti App Runtime / Publish runtime catalog (push) Canceled after 0s
878 lines
40 KiB
Go
878 lines
40 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"strings"
|
|
|
|
workspaceissues "github.com/tutti-os/tutti/packages/workspace/issues"
|
|
tuttigenerated "github.com/tutti-os/tutti/services/tuttid/api/generated"
|
|
workspaceapi "github.com/tutti-os/tutti/services/tuttid/api/workspace"
|
|
"github.com/tutti-os/tutti/services/tuttid/apierrors"
|
|
workspaceservice "github.com/tutti-os/tutti/services/tuttid/service/workspace"
|
|
)
|
|
|
|
func (api DaemonAPI) ListWorkspaceIssues(ctx context.Context, request tuttigenerated.ListWorkspaceIssuesRequestObject) (tuttigenerated.ListWorkspaceIssuesResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.ListWorkspaceIssues503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
list, err := api.IssueService.ListIssues(ctx, string(request.WorkspaceID), issueManagerIssueListInputFromGenerated(request.Params))
|
|
if err != nil {
|
|
return writeListWorkspaceIssuesError(err), nil
|
|
}
|
|
return tuttigenerated.ListWorkspaceIssues200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerIssueListResponseFromDomain(list),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) ListWorkspaceIssueTopics(ctx context.Context, request tuttigenerated.ListWorkspaceIssueTopicsRequestObject) (tuttigenerated.ListWorkspaceIssueTopicsResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.ListWorkspaceIssueTopics503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
list, err := api.IssueService.ListTopics(ctx, string(request.WorkspaceID))
|
|
if err != nil {
|
|
return writeListWorkspaceIssueTopicsError(err), nil
|
|
}
|
|
return tuttigenerated.ListWorkspaceIssueTopics200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTopicListResponseFromDomain(list),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssueTopic(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueTopicRequestObject) (tuttigenerated.CreateWorkspaceIssueTopicResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTopic503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTopic400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
topic, err := api.IssueService.CreateTopic(ctx, string(request.WorkspaceID), workspaceservice.CreateIssueManagerTopicInput{
|
|
TopicID: optionalString(request.Body.TopicId),
|
|
Title: request.Body.Title,
|
|
Summary: optionalString(request.Body.Summary),
|
|
})
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueTopicError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssueTopic201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTopicResponseFromDomain(topic),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) UpdateWorkspaceIssueTopic(ctx context.Context, request tuttigenerated.UpdateWorkspaceIssueTopicRequestObject) (tuttigenerated.UpdateWorkspaceIssueTopicResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.UpdateWorkspaceIssueTopic503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.UpdateWorkspaceIssueTopic400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
topic, err := api.IssueService.UpdateTopic(ctx, string(request.WorkspaceID), string(request.TopicID), workspaceservice.UpdateIssueManagerTopicInput{
|
|
Title: optionalString(request.Body.Title),
|
|
HasTitle: request.Body.Title != nil,
|
|
Summary: optionalString(request.Body.Summary),
|
|
HasSummary: request.Body.Summary != nil,
|
|
Pinned: optionalBool(request.Body.Pinned),
|
|
HasPinned: request.Body.Pinned != nil,
|
|
})
|
|
if err != nil {
|
|
return writeUpdateWorkspaceIssueTopicError(err), nil
|
|
}
|
|
return tuttigenerated.UpdateWorkspaceIssueTopic200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTopicResponseFromDomain(topic),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) DeleteWorkspaceIssueTopic(ctx context.Context, request tuttigenerated.DeleteWorkspaceIssueTopicRequestObject) (tuttigenerated.DeleteWorkspaceIssueTopicResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.DeleteWorkspaceIssueTopic503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
removed, err := api.IssueService.DeleteTopic(ctx, string(request.WorkspaceID), string(request.TopicID))
|
|
if err != nil {
|
|
return writeDeleteWorkspaceIssueTopicError(err), nil
|
|
}
|
|
return tuttigenerated.DeleteWorkspaceIssueTopic200JSONResponse{Removed: removed}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssue(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueRequestObject) (tuttigenerated.CreateWorkspaceIssueResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssue503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssue400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
input, err := issueManagerCreateIssueInputFromGenerated(*request.Body)
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueError(err), nil
|
|
}
|
|
issue, err := api.IssueService.CreateIssue(ctx, string(request.WorkspaceID), input)
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssue201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerIssueResponseFromDomain(issue),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssueFromPlan(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueFromPlanRequestObject) (tuttigenerated.CreateWorkspaceIssueFromPlanResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueFromPlan503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueFromPlan400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
tasks := make([]workspaceservice.CreateIssueManagerTaskItemInput, 0, len(request.Body.Tasks))
|
|
for _, task := range request.Body.Tasks {
|
|
tasks = append(tasks, issueManagerCreateTaskInputFromGenerated(task))
|
|
}
|
|
detail, err := api.IssueService.CreateIssueFromPlan(ctx, string(request.WorkspaceID), workspaceservice.CreateIssueManagerIssueFromPlanInput{
|
|
Issue: issueManagerCreatePlannedIssueInputFromGenerated(request.Body.Issue),
|
|
Tasks: tasks,
|
|
})
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueFromPlanError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssueFromPlan201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerIssueDetailResponseFromDomain(
|
|
detail,
|
|
api.IssueService.ProjectIssueManagerContextRefs(detail.ContextRefs),
|
|
),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) EstimateWorkspaceIssueAutoTokenBudget(ctx context.Context, request tuttigenerated.EstimateWorkspaceIssueAutoTokenBudgetRequestObject) (tuttigenerated.EstimateWorkspaceIssueAutoTokenBudgetResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.EstimateWorkspaceIssueAutoTokenBudget503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.EstimateWorkspaceIssueAutoTokenBudget400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
tasks := make([]workspaceservice.CreateIssueManagerTaskItemInput, 0, len(request.Body.Tasks))
|
|
for _, task := range request.Body.Tasks {
|
|
tasks = append(tasks, workspaceservice.CreateIssueManagerTaskItemInput{
|
|
AgentTargetID: optionalString(task.AgentTargetId),
|
|
ModelPlanID: optionalString(task.ModelPlanId),
|
|
Model: optionalString(task.Model),
|
|
})
|
|
}
|
|
estimate, err := api.IssueService.EstimateAutoTokenBudget(ctx, string(request.WorkspaceID), workspaceservice.EstimateIssueManagerAutoTokenBudgetInput{
|
|
ExecutionProfile: issueManagerExecutionProfileFromGenerated(&request.Body.ExecutionProfile),
|
|
Tasks: tasks,
|
|
})
|
|
if err != nil {
|
|
return writeEstimateWorkspaceIssueAutoTokenBudgetError(err), nil
|
|
}
|
|
return tuttigenerated.EstimateWorkspaceIssueAutoTokenBudget200JSONResponse{
|
|
TokenLimit: estimate.TokenLimit,
|
|
DeterministicTokenLimit: estimate.DeterministicTokenLimit,
|
|
HistoricalTokenEstimate: estimate.HistoricalTokenEstimate,
|
|
MatchedTaskCount: estimate.MatchedHistoricalTaskCount,
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) RemoveWorkspaceIssueTaskContextRef(ctx context.Context, request tuttigenerated.RemoveWorkspaceIssueTaskContextRefRequestObject) (tuttigenerated.RemoveWorkspaceIssueTaskContextRefResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.RemoveWorkspaceIssueTaskContextRef503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
removed, err := api.IssueService.RemoveTaskContextRef(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID), string(request.ContextRefID))
|
|
if err != nil {
|
|
return writeRemoveWorkspaceIssueTaskContextRefError(err), nil
|
|
}
|
|
return tuttigenerated.RemoveWorkspaceIssueTaskContextRef200JSONResponse{Removed: removed}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) CancelWorkspaceIssueExecution(ctx context.Context, request tuttigenerated.CancelWorkspaceIssueExecutionRequestObject) (tuttigenerated.CancelWorkspaceIssueExecutionResponseObject, error) {
|
|
if api.IssueExecutionService == nil {
|
|
return tuttigenerated.CancelWorkspaceIssueExecution503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
canceled, err := api.IssueExecutionService.CancelIssueExecution(ctx, string(request.WorkspaceID), string(request.IssueID))
|
|
if err != nil {
|
|
return writeCancelWorkspaceIssueExecutionError(err), nil
|
|
}
|
|
return tuttigenerated.CancelWorkspaceIssueExecution200JSONResponse{CanceledRunCount: canceled}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) DeleteWorkspaceIssue(ctx context.Context, request tuttigenerated.DeleteWorkspaceIssueRequestObject) (tuttigenerated.DeleteWorkspaceIssueResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.DeleteWorkspaceIssue503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
removed, err := api.IssueService.DeleteIssue(ctx, string(request.WorkspaceID), string(request.IssueID))
|
|
if err != nil {
|
|
return writeDeleteWorkspaceIssueError(err), nil
|
|
}
|
|
return tuttigenerated.DeleteWorkspaceIssue200JSONResponse{Removed: removed}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) GetWorkspaceIssueDetail(ctx context.Context, request tuttigenerated.GetWorkspaceIssueDetailRequestObject) (tuttigenerated.GetWorkspaceIssueDetailResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.GetWorkspaceIssueDetail503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
detail, err := api.IssueService.GetIssueDetail(ctx, string(request.WorkspaceID), string(request.IssueID))
|
|
if err != nil {
|
|
return writeGetWorkspaceIssueDetailError(err), nil
|
|
}
|
|
return tuttigenerated.GetWorkspaceIssueDetail200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerIssueDetailResponseFromDomain(
|
|
detail,
|
|
api.IssueService.ProjectIssueManagerContextRefs(detail.ContextRefs),
|
|
),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) SearchWorkspaceIssueReferences(ctx context.Context, request tuttigenerated.SearchWorkspaceIssueReferencesRequestObject) (tuttigenerated.SearchWorkspaceIssueReferencesResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.SearchWorkspaceIssueReferences503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.SearchWorkspaceIssueReferences400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
var filters []string
|
|
if request.Body.Filters != nil {
|
|
filters = *request.Body.Filters
|
|
}
|
|
hits, err := api.IssueService.SearchIssueOutputs(ctx, workspaceissues.RunOutputSearchParams{
|
|
WorkspaceID: string(request.WorkspaceID),
|
|
Query: request.Body.Query,
|
|
Filters: filters,
|
|
IssueID: optionalString(request.Body.IssueId),
|
|
TopicID: optionalString(request.Body.TopicId),
|
|
Limit: optionalInt(request.Body.Limit),
|
|
})
|
|
if err != nil {
|
|
return writeSearchWorkspaceIssueReferencesError(err), nil
|
|
}
|
|
return tuttigenerated.SearchWorkspaceIssueReferences200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerReferenceSearchResponseFromDomain(string(request.WorkspaceID), hits),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) UpdateWorkspaceIssue(ctx context.Context, request tuttigenerated.UpdateWorkspaceIssueRequestObject) (tuttigenerated.UpdateWorkspaceIssueResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.UpdateWorkspaceIssue503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.UpdateWorkspaceIssue400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
issue, err := api.IssueService.UpdateIssue(ctx, string(request.WorkspaceID), string(request.IssueID), workspaceservice.UpdateIssueManagerIssueInput{
|
|
Title: optionalString(request.Body.Title),
|
|
HasTitle: request.Body.Title != nil,
|
|
Content: optionalString(request.Body.Content),
|
|
HasContent: request.Body.Content != nil,
|
|
Status: optionalIssueManagerStatus(request.Body.Status),
|
|
HasStatus: request.Body.Status != nil,
|
|
})
|
|
if err != nil {
|
|
return writeUpdateWorkspaceIssueError(err), nil
|
|
}
|
|
return tuttigenerated.UpdateWorkspaceIssue200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerIssueResponseFromDomain(issue),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) AddWorkspaceIssueContextRefs(ctx context.Context, request tuttigenerated.AddWorkspaceIssueContextRefsRequestObject) (tuttigenerated.AddWorkspaceIssueContextRefsResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.AddWorkspaceIssueContextRefs503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.AddWorkspaceIssueContextRefs400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
refs, err := api.IssueService.AddIssueContextRefs(ctx, string(request.WorkspaceID), string(request.IssueID), workspaceservice.AddIssueManagerContextRefsInput{
|
|
Refs: issueManagerContextRefsInputFromGenerated(request.Body.Refs),
|
|
})
|
|
if err != nil {
|
|
return writeAddWorkspaceIssueContextRefsError(err), nil
|
|
}
|
|
return tuttigenerated.AddWorkspaceIssueContextRefs200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerContextRefsResponseFromService(
|
|
api.IssueService.ProjectIssueManagerContextRefs(refs),
|
|
),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) ListWorkspaceIssueTasks(ctx context.Context, request tuttigenerated.ListWorkspaceIssueTasksRequestObject) (tuttigenerated.ListWorkspaceIssueTasksResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.ListWorkspaceIssueTasks503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
list, err := api.IssueService.ListTasks(ctx, string(request.WorkspaceID), string(request.IssueID), issueManagerTaskListInputFromGenerated(request.Params))
|
|
if err != nil {
|
|
return writeListWorkspaceIssueTasksError(err), nil
|
|
}
|
|
return tuttigenerated.ListWorkspaceIssueTasks200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTaskListResponseFromDomain(list),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssueTask(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueTaskRequestObject) (tuttigenerated.CreateWorkspaceIssueTaskResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTask503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTask400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
task, err := api.IssueService.CreateTask(ctx, string(request.WorkspaceID), string(request.IssueID), workspaceservice.CreateIssueManagerTaskInput{
|
|
TaskID: optionalString(request.Body.TaskId),
|
|
Title: request.Body.Title,
|
|
Content: optionalString(request.Body.Content),
|
|
Priority: optionalIssueManagerPriority(request.Body.Priority),
|
|
DueAtUnixMS: optionalUnixMillis(request.Body.DueAtUnix),
|
|
})
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueTaskError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssueTask201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTaskResponseFromDomain(task),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssueTasks(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueTasksRequestObject) (tuttigenerated.CreateWorkspaceIssueTasksResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTasks503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTasks400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
tasksInput := make([]workspaceservice.CreateIssueManagerTaskItemInput, 0, len(request.Body.Tasks))
|
|
for _, task := range request.Body.Tasks {
|
|
tasksInput = append(tasksInput, workspaceservice.CreateIssueManagerTaskItemInput{
|
|
TaskID: optionalString(task.TaskId),
|
|
Title: task.Title,
|
|
Content: optionalString(task.Content),
|
|
Priority: optionalIssueManagerPriority(task.Priority),
|
|
DueAtUnixMS: optionalUnixMillis(task.DueAtUnix),
|
|
})
|
|
}
|
|
tasks, err := api.IssueService.CreateTasks(ctx, string(request.WorkspaceID), string(request.IssueID), workspaceservice.CreateIssueManagerTasksInput{
|
|
Tasks: tasksInput,
|
|
})
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueTasksError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssueTasks201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTasksResponseFromDomain(tasks),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) DeleteWorkspaceIssueTask(ctx context.Context, request tuttigenerated.DeleteWorkspaceIssueTaskRequestObject) (tuttigenerated.DeleteWorkspaceIssueTaskResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.DeleteWorkspaceIssueTask503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
removed, err := api.IssueService.DeleteTask(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID))
|
|
if err != nil {
|
|
return writeDeleteWorkspaceIssueTaskError(err), nil
|
|
}
|
|
return tuttigenerated.DeleteWorkspaceIssueTask200JSONResponse{Removed: removed}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) GetWorkspaceIssueTaskDetail(ctx context.Context, request tuttigenerated.GetWorkspaceIssueTaskDetailRequestObject) (tuttigenerated.GetWorkspaceIssueTaskDetailResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.GetWorkspaceIssueTaskDetail503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
detail, err := api.IssueService.GetTaskDetail(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID))
|
|
if err != nil {
|
|
return writeGetWorkspaceIssueTaskDetailError(err), nil
|
|
}
|
|
return tuttigenerated.GetWorkspaceIssueTaskDetail200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTaskDetailResponseFromDomain(
|
|
detail,
|
|
api.IssueService.ProjectIssueManagerContextRefs(detail.ContextRefs),
|
|
),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) UpdateWorkspaceIssueTask(ctx context.Context, request tuttigenerated.UpdateWorkspaceIssueTaskRequestObject) (tuttigenerated.UpdateWorkspaceIssueTaskResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.UpdateWorkspaceIssueTask503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.UpdateWorkspaceIssueTask400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
task, err := api.IssueService.UpdateTask(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID), workspaceservice.UpdateIssueManagerTaskInput{
|
|
Title: optionalString(request.Body.Title),
|
|
HasTitle: request.Body.Title != nil,
|
|
Content: optionalString(request.Body.Content),
|
|
HasContent: request.Body.Content != nil,
|
|
Status: optionalIssueManagerStatus(request.Body.Status),
|
|
HasStatus: request.Body.Status != nil,
|
|
Priority: optionalIssueManagerPriority(request.Body.Priority),
|
|
HasPriority: request.Body.Priority != nil,
|
|
DueAtUnixMS: optionalUnixMillis(request.Body.DueAtUnix),
|
|
HasDueAt: request.Body.DueAtUnix != nil,
|
|
SortIndex: optionalInt(request.Body.SortIndex),
|
|
HasSortIndex: request.Body.SortIndex != nil,
|
|
Parallelizable: request.Body.Parallelizable != nil && *request.Body.Parallelizable,
|
|
HasParallelizable: request.Body.Parallelizable != nil,
|
|
AutoAccept: request.Body.AutoAccept != nil && *request.Body.AutoAccept,
|
|
HasAutoAccept: request.Body.AutoAccept != nil,
|
|
AcceptanceState: optionalAcceptanceState(request.Body.AcceptanceState),
|
|
HasAcceptanceState: request.Body.AcceptanceState != nil,
|
|
AcceptanceSummary: optionalString(request.Body.AcceptanceSummary),
|
|
HasAcceptanceSummary: request.Body.AcceptanceSummary != nil,
|
|
})
|
|
if err != nil {
|
|
return writeUpdateWorkspaceIssueTaskError(err), nil
|
|
}
|
|
return tuttigenerated.UpdateWorkspaceIssueTask200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerTaskResponseFromDomain(task),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) AddWorkspaceIssueTaskContextRefs(ctx context.Context, request tuttigenerated.AddWorkspaceIssueTaskContextRefsRequestObject) (tuttigenerated.AddWorkspaceIssueTaskContextRefsResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.AddWorkspaceIssueTaskContextRefs503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.AddWorkspaceIssueTaskContextRefs400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
refs, err := api.IssueService.AddTaskContextRefs(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID), workspaceservice.AddIssueManagerContextRefsInput{
|
|
Refs: issueManagerContextRefsInputFromGenerated(request.Body.Refs),
|
|
})
|
|
if err != nil {
|
|
return writeAddWorkspaceIssueTaskContextRefsError(err), nil
|
|
}
|
|
return tuttigenerated.AddWorkspaceIssueTaskContextRefs200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerContextRefsResponseFromService(
|
|
api.IssueService.ProjectIssueManagerContextRefs(refs),
|
|
),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) ListWorkspaceIssueRuns(ctx context.Context, request tuttigenerated.ListWorkspaceIssueRunsRequestObject) (tuttigenerated.ListWorkspaceIssueRunsResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.ListWorkspaceIssueRuns503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
runs, err := api.IssueService.ListRuns(ctx, string(request.WorkspaceID), string(request.IssueID), "")
|
|
if err != nil {
|
|
return writeListWorkspaceIssueRunsError(err), nil
|
|
}
|
|
return tuttigenerated.ListWorkspaceIssueRuns200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunListResponseFromDomain(runs),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssueRun(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueRunRequestObject) (tuttigenerated.CreateWorkspaceIssueRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueRun400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
run, err := api.IssueService.CreateRun(ctx, string(request.WorkspaceID), string(request.IssueID), "", workspaceservice.CreateIssueManagerRunInput{
|
|
RunID: optionalString(request.Body.RunId),
|
|
AgentTargetID: request.Body.AgentTargetId,
|
|
AgentProvider: optionalString(request.Body.AgentProvider),
|
|
AgentUserID: optionalString(request.Body.AgentUserId),
|
|
AgentSessionID: optionalString(request.Body.AgentSessionId),
|
|
ExecutionDirectory: optionalString(request.Body.ExecutionDirectory),
|
|
})
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueRunError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssueRun201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunResponseFromDomain(run),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) StartWorkspaceIssueRun(ctx context.Context, request tuttigenerated.StartWorkspaceIssueRunRequestObject) (tuttigenerated.StartWorkspaceIssueRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.StartWorkspaceIssueRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.StartWorkspaceIssueRun400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
run, err := api.IssueService.StartIssueRun(ctx, string(request.WorkspaceID), string(request.IssueID), workspaceservice.StartIssueManagerRunInput{
|
|
AgentTargetID: request.Body.AgentTargetId,
|
|
ExecutionDirectory: optionalString(request.Body.ExecutionDirectory),
|
|
})
|
|
if err != nil {
|
|
return writeStartWorkspaceIssueRunError(err), nil
|
|
}
|
|
return tuttigenerated.StartWorkspaceIssueRun201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunResponseFromDomain(run),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) GetWorkspaceIssueRun(ctx context.Context, request tuttigenerated.GetWorkspaceIssueRunRequestObject) (tuttigenerated.GetWorkspaceIssueRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.GetWorkspaceIssueRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
detail, err := api.IssueService.GetRunDetail(ctx, string(request.WorkspaceID), string(request.IssueID), "", string(request.RunID))
|
|
if err != nil {
|
|
return writeGetWorkspaceIssueRunError(err), nil
|
|
}
|
|
return tuttigenerated.GetWorkspaceIssueRun200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunEnvelopeFromDomain(detail),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CompleteWorkspaceIssueRun(ctx context.Context, request tuttigenerated.CompleteWorkspaceIssueRunRequestObject) (tuttigenerated.CompleteWorkspaceIssueRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CompleteWorkspaceIssueRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CompleteWorkspaceIssueRun400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
detail, err := api.IssueService.CompleteRun(ctx, string(request.WorkspaceID), string(request.IssueID), "", string(request.RunID), workspaceservice.CompleteIssueManagerRunInput{
|
|
Status: string(request.Body.Status),
|
|
Summary: optionalString(request.Body.Summary),
|
|
ErrorMessage: optionalString(request.Body.ErrorMessage),
|
|
Outputs: issueManagerRunOutputsInputFromGenerated(request.Body.Outputs),
|
|
Usage: issueManagerTokenUsageFromGenerated(request.Body.Usage),
|
|
RemainingQuotaPercent: optionalFloat64(request.Body.RemainingQuotaPercent),
|
|
HasRemainingQuotaPercent: request.Body.RemainingQuotaPercent != nil,
|
|
})
|
|
if err != nil {
|
|
return writeCompleteWorkspaceIssueRunError(err), nil
|
|
}
|
|
return tuttigenerated.CompleteWorkspaceIssueRun200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunEnvelopeFromDomain(detail),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) ListWorkspaceIssueTaskRuns(ctx context.Context, request tuttigenerated.ListWorkspaceIssueTaskRunsRequestObject) (tuttigenerated.ListWorkspaceIssueTaskRunsResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.ListWorkspaceIssueTaskRuns503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
runs, err := api.IssueService.ListRuns(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID))
|
|
if err != nil {
|
|
return writeListWorkspaceIssueTaskRunsError(err), nil
|
|
}
|
|
return tuttigenerated.ListWorkspaceIssueTaskRuns200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunListResponseFromDomain(runs),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CreateWorkspaceIssueTaskRun(ctx context.Context, request tuttigenerated.CreateWorkspaceIssueTaskRunRequestObject) (tuttigenerated.CreateWorkspaceIssueTaskRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTaskRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CreateWorkspaceIssueTaskRun400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
run, err := api.IssueService.CreateRun(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID), workspaceservice.CreateIssueManagerRunInput{
|
|
RunID: optionalString(request.Body.RunId),
|
|
AgentTargetID: request.Body.AgentTargetId,
|
|
AgentProvider: optionalString(request.Body.AgentProvider),
|
|
AgentUserID: optionalString(request.Body.AgentUserId),
|
|
AgentSessionID: optionalString(request.Body.AgentSessionId),
|
|
ExecutionDirectory: optionalString(request.Body.ExecutionDirectory),
|
|
})
|
|
if err != nil {
|
|
return writeCreateWorkspaceIssueTaskRunError(err), nil
|
|
}
|
|
return tuttigenerated.CreateWorkspaceIssueTaskRun201JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunResponseFromDomain(run),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) GetWorkspaceIssueTaskRun(ctx context.Context, request tuttigenerated.GetWorkspaceIssueTaskRunRequestObject) (tuttigenerated.GetWorkspaceIssueTaskRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.GetWorkspaceIssueTaskRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
|
|
detail, err := api.IssueService.GetRunDetail(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID), string(request.RunID))
|
|
if err != nil {
|
|
return writeGetWorkspaceIssueTaskRunError(err), nil
|
|
}
|
|
return tuttigenerated.GetWorkspaceIssueTaskRun200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunEnvelopeFromDomain(detail),
|
|
), nil
|
|
}
|
|
|
|
func (api DaemonAPI) CompleteWorkspaceIssueTaskRun(ctx context.Context, request tuttigenerated.CompleteWorkspaceIssueTaskRunRequestObject) (tuttigenerated.CompleteWorkspaceIssueTaskRunResponseObject, error) {
|
|
if api.IssueService == nil {
|
|
return tuttigenerated.CompleteWorkspaceIssueTaskRun503JSONResponse{ServiceUnavailableErrorJSONResponse: issueManagerServiceUnavailableError()}, nil
|
|
}
|
|
if request.Body == nil {
|
|
return tuttigenerated.CompleteWorkspaceIssueTaskRun400JSONResponse{InvalidRequestErrorJSONResponse: issueManagerEmptyBodyError()}, nil
|
|
}
|
|
|
|
detail, err := api.IssueService.CompleteRun(ctx, string(request.WorkspaceID), string(request.IssueID), string(request.TaskID), string(request.RunID), workspaceservice.CompleteIssueManagerRunInput{
|
|
Status: string(request.Body.Status),
|
|
Summary: optionalString(request.Body.Summary),
|
|
ErrorMessage: optionalString(request.Body.ErrorMessage),
|
|
Outputs: issueManagerRunOutputsInputFromGenerated(request.Body.Outputs),
|
|
Usage: issueManagerTokenUsageFromGenerated(request.Body.Usage),
|
|
RemainingQuotaPercent: optionalFloat64(request.Body.RemainingQuotaPercent),
|
|
HasRemainingQuotaPercent: request.Body.RemainingQuotaPercent != nil,
|
|
})
|
|
if err != nil {
|
|
return writeCompleteWorkspaceIssueTaskRunError(err), nil
|
|
}
|
|
return tuttigenerated.CompleteWorkspaceIssueTaskRun200JSONResponse(
|
|
workspaceapi.GeneratedIssueManagerRunEnvelopeFromDomain(detail),
|
|
), nil
|
|
}
|
|
|
|
func issueManagerIssueListInputFromGenerated(params tuttigenerated.ListWorkspaceIssuesParams) workspaceservice.ListIssueManagerItemsInput {
|
|
input := workspaceservice.ListIssueManagerItemsInput{
|
|
TopicID: string(params.TopicId),
|
|
}
|
|
if params.PageSize != nil {
|
|
input.PageSize = int(*params.PageSize)
|
|
}
|
|
if params.PageToken != nil {
|
|
input.PageToken = string(*params.PageToken)
|
|
}
|
|
if params.StatusFilter != nil {
|
|
input.StatusFilter = string(*params.StatusFilter)
|
|
}
|
|
if params.SearchQuery != nil {
|
|
input.SearchQuery = string(*params.SearchQuery)
|
|
}
|
|
return input
|
|
}
|
|
|
|
func issueManagerTaskListInputFromGenerated(params tuttigenerated.ListWorkspaceIssueTasksParams) workspaceservice.ListIssueManagerItemsInput {
|
|
input := workspaceservice.ListIssueManagerItemsInput{}
|
|
if params.PageSize != nil {
|
|
input.PageSize = int(*params.PageSize)
|
|
}
|
|
if params.PageToken != nil {
|
|
input.PageToken = string(*params.PageToken)
|
|
}
|
|
if params.StatusFilter != nil {
|
|
input.StatusFilter = string(*params.StatusFilter)
|
|
}
|
|
if params.SearchQuery != nil {
|
|
input.SearchQuery = string(*params.SearchQuery)
|
|
}
|
|
return input
|
|
}
|
|
|
|
func issueManagerCreateIssueInputFromGenerated(item tuttigenerated.CreateIssueManagerIssueRequest) (workspaceservice.CreateIssueManagerIssueInput, error) {
|
|
attachments, err := issueManagerImageAttachmentsInputFromGenerated(item.Attachments)
|
|
if err != nil {
|
|
return workspaceservice.CreateIssueManagerIssueInput{}, err
|
|
}
|
|
return workspaceservice.CreateIssueManagerIssueInput{
|
|
IssueID: optionalString(item.IssueId),
|
|
TopicID: item.TopicId,
|
|
Title: item.Title,
|
|
Content: optionalString(item.Content),
|
|
PlanningSource: optionalPlanningSource(item.PlanningSource),
|
|
SourceSessionID: optionalString(item.SourceSessionId),
|
|
SequentialExecution: optionalBool(item.SequentialExecution),
|
|
ParallelExecution: optionalBool(item.ParallelExecution),
|
|
ExecutionProfile: issueManagerExecutionProfileFromGenerated(item.ExecutionProfile),
|
|
HasExecutionProfile: item.ExecutionProfile != nil,
|
|
Budget: issueManagerBudgetFromGenerated(item.Budget),
|
|
HasBudget: item.Budget != nil,
|
|
Attachments: attachments,
|
|
}, nil
|
|
}
|
|
|
|
func issueManagerCreatePlannedIssueInputFromGenerated(item tuttigenerated.CreateIssueManagerPlannedIssueRequest) workspaceservice.CreateIssueManagerIssueInput {
|
|
return workspaceservice.CreateIssueManagerIssueInput{
|
|
IssueID: optionalString(item.IssueId),
|
|
TopicID: item.TopicId,
|
|
Title: item.Title,
|
|
Content: optionalString(item.Content),
|
|
PlanningSource: optionalPlanningSource(item.PlanningSource),
|
|
SourceSessionID: optionalString(item.SourceSessionId),
|
|
SequentialExecution: optionalBool(item.SequentialExecution),
|
|
ParallelExecution: optionalBool(item.ParallelExecution),
|
|
ExecutionProfile: issueManagerExecutionProfileFromGenerated(item.ExecutionProfile),
|
|
HasExecutionProfile: item.ExecutionProfile != nil,
|
|
Budget: issueManagerBudgetFromGenerated(item.Budget),
|
|
HasBudget: item.Budget != nil,
|
|
}
|
|
}
|
|
|
|
func issueManagerImageAttachmentsInputFromGenerated(items *[]tuttigenerated.CreateIssueManagerImageAttachmentRequest) ([]workspaceservice.CreateIssueManagerImageAttachmentInput, error) {
|
|
if items == nil {
|
|
return nil, nil
|
|
}
|
|
if len(*items) > 8 {
|
|
return nil, workspaceissues.ErrInvalidArgument
|
|
}
|
|
attachments := make([]workspaceservice.CreateIssueManagerImageAttachmentInput, 0, len(*items))
|
|
for _, item := range *items {
|
|
encoded := strings.TrimSpace(item.DataBase64)
|
|
if !item.MimeType.Valid() || encoded == "" {
|
|
return nil, workspaceissues.ErrInvalidArgument
|
|
}
|
|
data, err := base64.StdEncoding.DecodeString(encoded)
|
|
if err != nil {
|
|
return nil, workspaceissues.ErrInvalidArgument
|
|
}
|
|
attachmentID := ""
|
|
if item.AttachmentId != nil {
|
|
attachmentID = item.AttachmentId.String()
|
|
}
|
|
attachments = append(attachments, workspaceservice.CreateIssueManagerImageAttachmentInput{
|
|
AttachmentID: attachmentID,
|
|
DisplayName: optionalString(item.DisplayName),
|
|
MimeType: string(item.MimeType),
|
|
Data: data,
|
|
})
|
|
}
|
|
return attachments, nil
|
|
}
|
|
|
|
func issueManagerCreateTaskInputFromGenerated(item tuttigenerated.CreateIssueManagerTaskRequest) workspaceservice.CreateIssueManagerTaskItemInput {
|
|
return workspaceservice.CreateIssueManagerTaskItemInput{
|
|
TaskID: optionalString(item.TaskId),
|
|
Title: item.Title,
|
|
Content: optionalString(item.Content),
|
|
Priority: optionalIssueManagerPriority(item.Priority),
|
|
DueAtUnixMS: optionalUnixMillis(item.DueAtUnix),
|
|
AgentTargetID: optionalString(item.AgentTargetId),
|
|
ModelPlanID: optionalString(item.ModelPlanId),
|
|
Model: optionalString(item.Model),
|
|
ExecutionDirectory: optionalString(item.ExecutionDirectory),
|
|
DependencyTaskIDs: issueManagerOptionalStringSlice(item.DependencyTaskIds),
|
|
Parallelizable: item.Parallelizable != nil && *item.Parallelizable,
|
|
AutoAccept: item.AutoAccept != nil && *item.AutoAccept,
|
|
}
|
|
}
|
|
|
|
func issueManagerExecutionProfileFromGenerated(value *tuttigenerated.IssueManagerExecutionProfile) workspaceissues.ExecutionProfile {
|
|
if value == nil {
|
|
return workspaceissues.ExecutionProfile{}
|
|
}
|
|
return workspaceissues.ExecutionProfile{ReasoningIntensity: value.ReasoningIntensity, OrchestrationIntensity: value.OrchestrationIntensity}
|
|
}
|
|
|
|
func issueManagerBudgetFromGenerated(value *tuttigenerated.IssueManagerBudget) workspaceissues.Budget {
|
|
if value == nil {
|
|
return workspaceissues.Budget{}
|
|
}
|
|
return workspaceissues.Budget{Mode: workspaceissues.BudgetMode(value.Mode), TokenLimit: value.TokenLimit, ConsumedTokens: value.ConsumedTokens, QuotaWaterlinePercent: value.QuotaWaterlinePercent, RemainingQuotaPercent: optionalFloat64(value.RemainingQuotaPercent), HasRemainingQuota: value.RemainingQuotaPercent != nil, Status: workspaceissues.BudgetStatus(value.Status)}
|
|
}
|
|
|
|
func issueManagerTokenUsageFromGenerated(value *tuttigenerated.IssueManagerTokenUsage) workspaceissues.TokenUsage {
|
|
if value == nil {
|
|
return workspaceissues.TokenUsage{}
|
|
}
|
|
return workspaceissues.TokenUsage{InputTokens: value.InputTokens, OutputTokens: value.OutputTokens, CacheReadTokens: value.CacheReadTokens, CacheWriteTokens: value.CacheWriteTokens}
|
|
}
|
|
|
|
func optionalFloat64(value *float64) float64 {
|
|
if value == nil {
|
|
return 0
|
|
}
|
|
return *value
|
|
}
|
|
|
|
func issueManagerOptionalStringSlice(value *[]string) []string {
|
|
if value == nil {
|
|
return nil
|
|
}
|
|
return append([]string(nil), (*value)...)
|
|
}
|
|
|
|
func optionalPlanningSource(value *tuttigenerated.IssueManagerPlanningSource) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return string(*value)
|
|
}
|
|
|
|
func issueManagerContextRefsInputFromGenerated(items []tuttigenerated.AddIssueManagerContextRefItem) []workspaceissues.AddContextRefInput {
|
|
refs := make([]workspaceissues.AddContextRefInput, 0, len(items))
|
|
for _, item := range items {
|
|
refs = append(refs, workspaceissues.AddContextRefInput{
|
|
ContextRefID: optionalString(item.ContextRefId),
|
|
RefType: item.RefType,
|
|
Path: item.Path,
|
|
DisplayName: optionalString(item.DisplayName),
|
|
})
|
|
}
|
|
return refs
|
|
}
|
|
|
|
func issueManagerRunOutputsInputFromGenerated(items []tuttigenerated.CompleteIssueManagerRunOutputItem) []workspaceissues.CompleteRunOutputInput {
|
|
outputs := make([]workspaceissues.CompleteRunOutputInput, 0, len(items))
|
|
for _, item := range items {
|
|
outputs = append(outputs, workspaceissues.CompleteRunOutputInput{
|
|
OutputID: optionalString(item.OutputId),
|
|
Path: item.Path,
|
|
DisplayName: optionalString(item.DisplayName),
|
|
MediaType: optionalString(item.MediaType),
|
|
SizeBytes: optionalInt64(item.SizeBytes),
|
|
})
|
|
}
|
|
return outputs
|
|
}
|
|
|
|
func issueManagerEmptyBodyError() tuttigenerated.InvalidRequestErrorJSONResponse {
|
|
return invalidRequestError(apierrors.EmptyBody(apierrors.WithDeveloperMessage("empty body")))
|
|
}
|
|
|
|
func optionalString(value *string) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(*value)
|
|
}
|
|
|
|
func optionalInt64(value *int64) int64 {
|
|
if value == nil {
|
|
return 0
|
|
}
|
|
return *value
|
|
}
|
|
|
|
func optionalInt(value *int) int {
|
|
if value == nil {
|
|
return 0
|
|
}
|
|
return *value
|
|
}
|
|
|
|
func optionalBool(value *bool) bool {
|
|
if value == nil {
|
|
return false
|
|
}
|
|
return *value
|
|
}
|
|
|
|
func optionalUnixMillis(value *int64) int64 {
|
|
return workspaceapi.UnixMillisFromSeconds(optionalInt64(value))
|
|
}
|
|
|
|
func optionalIssueManagerStatus(value *tuttigenerated.IssueManagerStatus) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return string(*value)
|
|
}
|
|
|
|
func optionalIssueManagerPriority(value *tuttigenerated.IssueManagerPriority) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return string(*value)
|
|
}
|
|
|
|
func optionalAcceptanceState(value *tuttigenerated.IssueManagerAcceptanceState) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return string(*value)
|
|
}
|