asteroid

type AsteroidChat struct {
	RequestData  string `json:"request_data"`
	ResponseData string `json:"response_data"`
}

type AsteroidChoice struct {
	AsteroidId   string                     `json:"asteroid_id"`
	FinishReason AsteroidChoiceFinishReason `json:"finish_reason"`
	Index        int                        `json:"index"`
	Message      AsteroidMessage            `json:"message"`
}

type AsteroidChoiceFinishReason string

type AsteroidConverter interface {
	ToAsteroidMessages(requestData, responseData []byte) ([]AsteroidMessage, error)
	ToAsteroidChoices(responseData []byte) ([]AsteroidChoice, error)
	ValidateB64EncodedRequest(encodedData string) ([]byte, error)
	ValidateB64EncodedResponse(encodedData string) ([]byte, error)
}

type AsteroidMessage struct {
	Content   string     `json:"content"`
	CreatedAt *time.Time `json:"created_at,omitempty"`

	// Data The raw b64 encoded JSON of the message objects in its original form
	Data      *string             `json:"data,omitempty"`
	Id        *openapi_types.UUID `json:"id,omitempty"`
	Role      AsteroidMessageRole `json:"role"`
	ToolCalls *[]AsteroidToolCall `json:"tool_calls,omitempty"`
	Type      *MessageType        `json:"type,omitempty"`
}

type AsteroidMessageRole string

type AsteroidToolCall struct {
	// Arguments Arguments in JSON format
	Arguments *string            `json:"arguments,omitempty"`
	CallId    *string            `json:"call_id,omitempty"`
	CreatedAt *time.Time         `json:"created_at,omitempty"`
	Id        openapi_types.UUID `json:"id"`
	Name      *string            `json:"name,omitempty"`
	ToolId    openapi_types.UUID `json:"tool_id"`
}

type ChainExecution struct {
	ChainId    openapi_types.UUID `json:"chain_id"`
	CreatedAt  time.Time          `json:"created_at"`
	Id         openapi_types.UUID `json:"id"`
	ToolcallId openapi_types.UUID `json:"toolcall_id"`
}

type ChainExecutionState struct {
	Chain               SupervisorChain           `json:"chain"`
	ChainExecution      ChainExecution            `json:"chain_execution"`
	SupervisionRequests []SupervisionRequestState `json:"supervision_requests"`
}

type ChainRequest struct {
	// SupervisorIds Array of supervisor IDs to create chains with
	SupervisorIds *[]openapi_types.UUID `json:"supervisor_ids,omitempty"`
}

type ChatIds struct {
	ChatId    openapi_types.UUID `json:"chat_id"`
	ChoiceIds []ChoiceIds        `json:"choice_ids"`
}

type ChatStore interface {
	CreateChatRequest(
		ctx context.Context,
		runId uuid.UUID,
		request []byte,
		response []byte,
		choices []AsteroidChoice,
		format string,
		requestMessages []AsteroidMessage,
	) (*uuid.UUID, error)
	// GetMessagesForRun(ctx context.Context, runId uuid.UUID, includeInvalidated bool) ([]AsteroidMessage, error)
	GetChat(ctx context.Context, runId uuid.UUID, index int) ([]byte, []byte, error)
	GetMessage(ctx context.Context, id uuid.UUID) (*AsteroidMessage, error)
	UpdateMessage(ctx context.Context, id uuid.UUID, message AsteroidMessage) error
	GetRunChatCount(ctx context.Context, runId uuid.UUID) (int, error)
}

type ChoiceIds struct {
	ChoiceId    string        `json:"choice_id"`
	MessageId   string        `json:"message_id"`
	ToolCallIds []ToolCallIds `json:"tool_call_ids"`
}

type Client struct {
	Hub  *Hub
	Conn *websocket.Conn
	Send chan SupervisionRequest
}

type CreateNewChatJSONRequestBody = AsteroidChat

type CreateProjectJSONBody struct {
	Name          string   `json:"name"`
	RunResultTags []string `json:"run_result_tags"`
}

type CreateProjectJSONRequestBody CreateProjectJSONBody

type CreateRunToolJSONBody struct {
	Attributes        map[string]interface{} `json:"attributes"`
	Code              string                 `json:"code"`
	Description       string                 `json:"description"`
	IgnoredAttributes *[]string              `json:"ignored_attributes,omitempty"`
	Name              string                 `json:"name"`
}

type CreateRunToolJSONRequestBody CreateRunToolJSONBody

type CreateSupervisionRequestJSONRequestBody = SupervisionRequest

type CreateSupervisionResultJSONRequestBody = SupervisionResult

type CreateSupervisorJSONRequestBody = Supervisor

type CreateTaskJSONBody struct {
	Description *string `json:"description,omitempty"`
	Name        string  `json:"name"`
}

type CreateTaskJSONRequestBody CreateTaskJSONBody

type CreateToolSupervisorChainsJSONBody = []ChainRequest

type CreateToolSupervisorChainsJSONRequestBody = CreateToolSupervisorChainsJSONBody

type Decision string

type ErrorResponse struct {
	Details *string `json:"details,omitempty"`
	Error   string  `json:"error"`
}

type Hub struct {
	// Clients is a map of clients to their connection status
	Clients      map[*Client]bool
	ClientsMutex sync.RWMutex
	// ReviewChan is a channel that receives new reviews, then assigns them to a connected client
	ReviewChan chan SupervisionRequest
	// Register and Unregister are used when a new client connects and disconnects
	Register   chan *Client
	Unregister chan *Client
	// AssignedReviews is a map of clients to the reviews they are currently processing
	AssignedReviews      map[*Client]map[string]bool
	AssignedReviewsMutex sync.RWMutex

	// CompletedReviewCount is used to count the number of reviews that have been completed
	CompletedReviewCount int
	Store                Store
}

type HubStats struct {
	AssignedReviews       map[string]int `json:"assigned_reviews"`
	AssignedReviewsCount  int            `json:"assigned_reviews_count"`
	BusyClients           int            `json:"busy_clients"`
	CompletedReviewsCount int            `json:"completed_reviews_count"`
	ConnectedClients      int            `json:"connected_clients"`
	FreeClients           int            `json:"free_clients"`
	PendingReviewsCount   int            `json:"pending_reviews_count"`
	ReviewDistribution    map[string]int `json:"review_distribution"`
}

type InvalidParamFormatError struct {
	ParamName string
	Err       error
}

type MessageRole string

type MessageType string

type MiddlewareFunc func(http.Handler) http.Handler

type OpenAIConverter struct {
	// contains filtered or unexported fields
}

type Processor struct {
	// contains filtered or unexported fields
}

type Project struct {
	CreatedAt     time.Time          `json:"created_at"`
	Id            openapi_types.UUID `json:"id"`
	Name          string             `json:"name"`
	RunResultTags []string           `json:"run_result_tags"`
}

type ProjectStore interface {
	CreateProject(ctx context.Context, project Project) error
	GetProject(ctx context.Context, id uuid.UUID) (*Project, error)
	GetProjectFromName(ctx context.Context, name string) (*Project, error)
	GetProjects(ctx context.Context) ([]Project, error)
}

type RequiredHeaderError struct {
	ParamName string
	Err       error
}

type RequiredParamError struct {
	ParamName string
}

type ReviewPayload struct {
	ChainState ChainExecutionState `json:"chain_state"`

	// Messages The messages in the run
	Messages []AsteroidMessage `json:"messages"`

	// RunId The ID of the run this review is for
	RunId              openapi_types.UUID `json:"run_id"`
	SupervisionRequest SupervisionRequest `json:"supervision_request"`
	Toolcall           AsteroidToolCall   `json:"toolcall"`
}

type Run struct {
	CreatedAt time.Time          `json:"created_at"`
	Id        openapi_types.UUID `json:"id"`
	Result    *string            `json:"result,omitempty"`
	Status    *Status            `json:"status,omitempty"`
	TaskId    openapi_types.UUID `json:"task_id"`
}

type RunExecution struct {
	Chains   []ChainExecutionState `json:"chains"`
	Status   Status                `json:"status"`
	Toolcall AsteroidToolCall      `json:"toolcall"`
}

type RunState = []RunExecution

type RunStore interface {
	CreateRun(ctx context.Context, run Run) (uuid.UUID, error)
	GetRun(ctx context.Context, id uuid.UUID) (*Run, error)
	GetRuns(ctx context.Context, taskId uuid.UUID) ([]Run, error)
	GetTaskRuns(ctx context.Context, taskId uuid.UUID) ([]Run, error)
	UpdateRunStatus(ctx context.Context, runId uuid.UUID, status Status) error
	UpdateRunResult(ctx context.Context, runId uuid.UUID, result string) error
}

type ServeMux interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	ServeHTTP(w http.ResponseWriter, r *http.Request)
}

type Server struct {
	Hub   *Hub
	Store Store
}

type ServerInterface interface {
	// Get the OpenAPI schema
	// (GET /openapi.yaml)
	GetOpenAPI(w http.ResponseWriter, r *http.Request)
	// Get all projects
	// (GET /project)
	GetProjects(w http.ResponseWriter, r *http.Request)
	// Create a new project
	// (POST /project)
	CreateProject(w http.ResponseWriter, r *http.Request)
	// Get a project
	// (GET /project/{projectId})
	GetProject(w http.ResponseWriter, r *http.Request, projectId openapi_types.UUID)
	// Get all supervisors
	// (GET /project/{projectId}/supervisor)
	GetSupervisors(w http.ResponseWriter, r *http.Request, projectId openapi_types.UUID)
	// Create a new supervisor
	// (POST /project/{projectId}/supervisor)
	CreateSupervisor(w http.ResponseWriter, r *http.Request, projectId openapi_types.UUID)
	// Get all tasks for a project
	// (GET /project/{projectId}/tasks)
	GetProjectTasks(w http.ResponseWriter, r *http.Request, projectId openapi_types.UUID)
	// Create a new task
	// (POST /project/{projectId}/tasks)
	CreateTask(w http.ResponseWriter, r *http.Request, projectId openapi_types.UUID)
	// Get all tools for a project
	// (GET /project/{projectId}/tools)
	GetProjectTools(w http.ResponseWriter, r *http.Request, projectId openapi_types.UUID)
	// Get a run
	// (GET /run/{runId})
	GetRun(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Update a run with a result
	// (PUT /run/{runId}/result)
	UpdateRunResult(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Get the status of a run
	// (GET /run/{runId}/status)
	GetRunStatus(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Update the status of a run
	// (PUT /run/{runId}/status)
	UpdateRunStatus(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Get all tools for a run
	// (GET /run/{runId}/tool)
	GetRunTools(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Create a new tool for a run
	// (POST /run/{runId}/tool)
	CreateRunTool(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Create a new chat completion request from an existing run
	// (POST /run/{run_id}/chat)
	CreateNewChat(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Count the number of chat entries for a run
	// (GET /run/{run_id}/chat_count)
	GetRunChatCount(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID)
	// Get the messages for a run
	// (GET /run/{run_id}/messages/{index})
	GetRunMessages(w http.ResponseWriter, r *http.Request, runId openapi_types.UUID, index int)
	// Get hub stats
	// (GET /stats)
	GetHubStats(w http.ResponseWriter, r *http.Request)
	// Get a supervision result
	// (GET /supervision_request/{supervisionRequestId}/result)
	GetSupervisionResult(w http.ResponseWriter, r *http.Request, supervisionRequestId openapi_types.UUID)
	// Create a supervision result for a supervision request
	// (POST /supervision_request/{supervisionRequestId}/result)
	CreateSupervisionResult(w http.ResponseWriter, r *http.Request, supervisionRequestId openapi_types.UUID)
	// Get the review payload for a supervision request
	// (GET /supervision_request/{supervisionRequestId}/review_payload)
	GetSupervisionReviewPayload(w http.ResponseWriter, r *http.Request, supervisionRequestId openapi_types.UUID)
	// Get a supervision request status
	// (GET /supervision_request/{supervisionRequestId}/status)
	GetSupervisionRequestStatus(w http.ResponseWriter, r *http.Request, supervisionRequestId openapi_types.UUID)
	// Get a supervisor
	// (GET /supervisor/{supervisorId})
	GetSupervisor(w http.ResponseWriter, r *http.Request, supervisorId openapi_types.UUID)
	// Get the Swagger UI
	// (GET /swagger-ui)
	GetSwaggerDocs(w http.ResponseWriter, r *http.Request)
	// Get a task
	// (GET /task/{taskId})
	GetTask(w http.ResponseWriter, r *http.Request, taskId openapi_types.UUID)
	// Get all runs for a task
	// (GET /task/{taskId}/run)
	GetTaskRuns(w http.ResponseWriter, r *http.Request, taskId openapi_types.UUID)
	// Create a new run for a task
	// (POST /task/{taskId}/run)
	CreateRun(w http.ResponseWriter, r *http.Request, taskId openapi_types.UUID)
	// Get a tool
	// (GET /tool/{toolId})
	GetTool(w http.ResponseWriter, r *http.Request, toolId openapi_types.UUID)
	// Get all supervisors for a tool, in chain format
	// (GET /tool/{toolId}/supervisors)
	GetToolSupervisorChains(w http.ResponseWriter, r *http.Request, toolId openapi_types.UUID)
	// Create new chains with supervisors for a tool
	// (POST /tool/{toolId}/supervisors)
	CreateToolSupervisorChains(w http.ResponseWriter, r *http.Request, toolId openapi_types.UUID)
	// Get a tool call
	// (GET /tool_call/{toolCallId})
	GetToolCall(w http.ResponseWriter, r *http.Request, toolCallId openapi_types.UUID)
	// Create a supervision request for a supervisor in a chain on a tool call
	// (POST /tool_call/{toolCallId}/chain/{chainId}/supervisor/{supervisorId}/supervision_request)
	CreateSupervisionRequest(w http.ResponseWriter, r *http.Request, toolCallId openapi_types.UUID, chainId openapi_types.UUID, supervisorId openapi_types.UUID)
	// Get the state of a tool call
	// (GET /tool_call/{toolCallId}/state)
	GetToolCallState(w http.ResponseWriter, r *http.Request, toolCallId string)
	// Get a tool call status
	// (GET /tool_call/{toolCallId}/status)
	GetToolCallStatus(w http.ResponseWriter, r *http.Request, toolCallId openapi_types.UUID)
}

type ServerInterfaceWrapper struct {
	Handler            ServerInterface
	HandlerMiddlewares []MiddlewareFunc
	ErrorHandlerFunc   func(w http.ResponseWriter, r *http.Request, err error)
}

type Status string

type StdHTTPServerOptions struct {
	BaseURL          string
	BaseRouter       ServeMux
	Middlewares      []MiddlewareFunc
	ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request, err error)
}

type Store interface {
	ProjectStore
	RunStore
	ToolStore
	ToolRequestStore
	SupervisorStore
	SupervisionStore
	TaskStore
	ChatStore
}

type SupervisionRequest struct {
	ChainexecutionId *openapi_types.UUID `json:"chainexecution_id,omitempty"`
	Id               *openapi_types.UUID `json:"id,omitempty"`
	PositionInChain  int                 `json:"position_in_chain"`
	Status           *SupervisionStatus  `json:"status,omitempty"`
	SupervisorId     openapi_types.UUID  `json:"supervisor_id"`
}

type SupervisionRequestState struct {
	Result             *SupervisionResult `json:"result,omitempty"`
	Status             SupervisionStatus  `json:"status"`
	SupervisionRequest SupervisionRequest `json:"supervision_request"`
}

type SupervisionResult struct {
	CreatedAt            time.Time           `json:"created_at"`
	Decision             Decision            `json:"decision"`
	Id                   *openapi_types.UUID `json:"id,omitempty"`
	Reasoning            string              `json:"reasoning"`
	SupervisionRequestId openapi_types.UUID  `json:"supervision_request_id"`
	ToolcallId           *openapi_types.UUID `json:"toolcall_id,omitempty"`
}

type SupervisionStatus struct {
	CreatedAt            time.Time           `json:"created_at"`
	Id                   int                 `json:"id"`
	Status               Status              `json:"status"`
	SupervisionRequestId *openapi_types.UUID `json:"supervision_request_id,omitempty"`
}

type SupervisionStore interface {
	// Requests
	CreateSupervisionRequest(ctx context.Context, request SupervisionRequest, chainId uuid.UUID, toolCallId uuid.UUID) (*uuid.UUID, error)
	GetSupervisionRequest(ctx context.Context, id uuid.UUID) (*SupervisionRequest, error)
	GetSupervisionRequestsForStatus(ctx context.Context, status Status) ([]SupervisionRequest, error)

	// Results
	GetSupervisionResultFromRequestID(ctx context.Context, requestId uuid.UUID) (*SupervisionResult, error)
	CreateSupervisionResult(ctx context.Context, result SupervisionResult, requestId uuid.UUID) (*uuid.UUID, error)

	// Statuses
	CreateSupervisionStatus(ctx context.Context, requestID uuid.UUID, status SupervisionStatus) error

	// Util
	CountSupervisionRequests(ctx context.Context, status Status) (int, error)

	GetChainExecutionSupervisionRequests(ctx context.Context, chainExecutionId uuid.UUID) ([]SupervisionRequest, error)
	GetSupervisionRequestStatus(ctx context.Context, requestId uuid.UUID) (*SupervisionStatus, error)

	GetExecutionFromChainId(ctx context.Context, chainId uuid.UUID) (*uuid.UUID, error)
	GetChainExecution(ctx context.Context, executionId uuid.UUID) (*uuid.UUID, *uuid.UUID, error)
	GetChainExecutionFromChainAndToolCall(ctx context.Context, chainId uuid.UUID, toolCallId uuid.UUID) (*uuid.UUID, error)
	GetChainExecutionsFromToolCall(ctx context.Context, id uuid.UUID) ([]uuid.UUID, error)
	GetChainExecutionState(ctx context.Context, executionId uuid.UUID) (*ChainExecutionState, error)
}

type Supervisor struct {
	Attributes  map[string]interface{} `json:"attributes"`
	Code        string                 `json:"code"`
	CreatedAt   time.Time              `json:"created_at"`
	Description string                 `json:"description"`
	Id          *openapi_types.UUID    `json:"id,omitempty"`
	Name        string                 `json:"name"`

	// Type The type of supervisor. ClientSupervisor means that the supervision is done client side and the server is merely informed. Other supervisor types are handled serverside, e.g. HumanSupervisor means that a human will review the request via the Asteroid UI.
	Type SupervisorType `json:"type"`
}

type SupervisorChain struct {
	ChainId     openapi_types.UUID `json:"chain_id"`
	Supervisors []Supervisor       `json:"supervisors"`
}

type SupervisorStore interface {
	CreateSupervisor(ctx context.Context, supervisor Supervisor) (uuid.UUID, error)
	GetSupervisor(ctx context.Context, id uuid.UUID) (*Supervisor, error)
	GetSupervisorFromValues(ctx context.Context, code string, name string, desc string, t SupervisorType, attributes map[string]interface{}) (*Supervisor, error)
	GetSupervisors(ctx context.Context, projectId uuid.UUID) ([]Supervisor, error)
	CreateSupervisorChain(ctx context.Context, toolId uuid.UUID, chain ChainRequest) (*uuid.UUID, error)
	GetSupervisorChains(ctx context.Context, toolId uuid.UUID) ([]SupervisorChain, error)
	GetSupervisorChain(ctx context.Context, id uuid.UUID) (*SupervisorChain, error)
}

type SupervisorType string

type Task struct {
	CreatedAt   time.Time          `json:"created_at"`
	Description *string            `json:"description,omitempty"`
	Id          openapi_types.UUID `json:"id"`
	Name        string             `json:"name"`
	ProjectId   openapi_types.UUID `json:"project_id"`
}

type TaskStore interface {
	CreateTask(ctx context.Context, task Task) (*uuid.UUID, error)
	GetTask(ctx context.Context, id uuid.UUID) (*Task, error)
	GetProjectTasks(ctx context.Context, projectId uuid.UUID) ([]Task, error)
}

type TooManyValuesForParamError struct {
	ParamName string
	Count     int
}

type Tool struct {
	Attributes        map[string]interface{} `json:"attributes"`
	Code              string                 `json:"code"`
	Description       string                 `json:"description"`
	Id                *openapi_types.UUID    `json:"id,omitempty"`
	IgnoredAttributes *[]string              `json:"ignored_attributes,omitempty"`
	Name              string                 `json:"name"`
	RunId             openapi_types.UUID     `json:"run_id"`
}

type ToolCallIds struct {
	ToolCallId *string `json:"tool_call_id,omitempty"`
	ToolId     *string `json:"tool_id,omitempty"`
}

type ToolRequestStore interface {
	// CreateToolRequestGroup(ctx context.Context, toolId uuid.UUID, request ToolRequestGroup) (*ToolRequestGroup, error)
	// GetRunRequestGroups(ctx context.Context, runId uuid.UUID, includeArgs bool) ([]ToolRequestGroup, error)
	// GetRequestGroup(ctx context.Context, id uuid.UUID, includeArgs bool) (*ToolRequestGroup, error)
	// CreateToolCall(ctx context.Context, toolCallId uuid.UUID, request ToolRequest) (*uuid.UUID, error)
	GetToolCall(ctx context.Context, id uuid.UUID) (*AsteroidToolCall, error)
	GetToolCallFromCallId(ctx context.Context, id string) (*AsteroidToolCall, error)
}

type ToolStore interface {
	CreateTool(ctx context.Context, runId uuid.UUID, attributes map[string]interface{}, name string, description string, ignoredAttributes []string, code string) (*Tool, error)
	GetTool(ctx context.Context, id uuid.UUID) (*Tool, error)
	// GetToolFromValues(ctx context.Context, attributes map[string]interface{}, name string, description string, ignoredAttributes []string) (*Tool, error)
	GetRunTools(ctx context.Context, id uuid.UUID) ([]Tool, error)
	GetProjectTools(ctx context.Context, id uuid.UUID) ([]Tool, error)
	GetToolFromNameAndRunId(ctx context.Context, name string, runId uuid.UUID) (*Tool, error)
}

type UnescapedCookieParamError struct {
	ParamName string
	Err       error
}

type UnmarshalingParamError struct {
	ParamName string
	Err       error
}

type UpdateRunResultJSONBody struct {
	Result *string `json:"result,omitempty"`
}

type UpdateRunResultJSONRequestBody UpdateRunResultJSONBody

type UpdateRunStatusJSONRequestBody = Status