DEV-000069 general agent delegation codex bridge foundation
This commit is contained in:
@@ -12,6 +12,7 @@ import (
|
||||
|
||||
type attentionRepository interface {
|
||||
AttentionByOwner(context.Context, identity.PrincipalID, int) ([]continuity.AttentionItem, error)
|
||||
CreateAttentionItem(context.Context, continuity.AttentionItem) (continuity.AttentionItem, error)
|
||||
}
|
||||
|
||||
func registerCreatorAttentionRoutes(mux *http.ServeMux, identityClient creatorIdentityClient, repository attentionRepository) {
|
||||
@@ -61,6 +62,53 @@ func registerCreatorAttentionRoutes(mux *http.ServeMux, identityClient creatorId
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
_ = json.NewEncoder(w).Encode(result)
|
||||
})
|
||||
mux.HandleFunc("POST /v1/creator/attention", func(w http.ResponseWriter, r *http.Request) {
|
||||
session, ok := creatorSessionForAttention(w, r, identityClient)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var request continuity.CreateAttentionRequest
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(&request); err != nil {
|
||||
http.Error(w, "invalid attention request", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if request.OwnerPrincipalID == "" {
|
||||
request.OwnerPrincipalID = session.PrincipalID
|
||||
}
|
||||
if request.OwnerPrincipalID != session.PrincipalID || request.ScopeID == "" || request.SourceKind == "" || request.Level == "" || request.Summary == "" || request.CreatedAtUnixMillis < 1 || request.DueAtUnixMillis < 1 {
|
||||
http.Error(w, "invalid attention request", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if request.SourceKind == continuity.AttentionSourceAgentDelegation && request.SourceExternalRef == "" {
|
||||
http.Error(w, "delegation attention requires source external ref", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
item := continuity.AttentionItem{
|
||||
ID: continuity.AttentionItemID(request.SourceExternalRef),
|
||||
OwnerPrincipalID: request.OwnerPrincipalID,
|
||||
ScopeID: request.ScopeID,
|
||||
SourceKind: request.SourceKind,
|
||||
SourceProspectiveID: request.SourceProspectiveID,
|
||||
SourceExternalRef: request.SourceExternalRef,
|
||||
Level: request.Level,
|
||||
State: continuity.AttentionPending,
|
||||
Summary: request.Summary,
|
||||
DueAtUnixMillis: request.DueAtUnixMillis,
|
||||
CreatedAtUnixMillis: request.CreatedAtUnixMillis,
|
||||
Revision: 1,
|
||||
}
|
||||
saved, err := repository.CreateAttentionItem(r.Context(), item)
|
||||
if err != nil {
|
||||
http.Error(w, "attention unavailable", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_ = json.NewEncoder(w).Encode(saved)
|
||||
})
|
||||
}
|
||||
|
||||
func creatorSessionForAttention(w http.ResponseWriter, r *http.Request, identityClient creatorIdentityClient) (identity.CreatorSession, bool) {
|
||||
@@ -98,6 +146,15 @@ func humanAttentionState(state continuity.AttentionState) string {
|
||||
}
|
||||
|
||||
func humanResponseHint(item continuity.AttentionItem) string {
|
||||
if item.SourceKind == continuity.AttentionSourceAgentDelegation {
|
||||
if item.State == continuity.AttentionDelivered || item.State == continuity.AttentionPending || item.State == continuity.AttentionFailed {
|
||||
return "Можно ответить: «Продолжай» или «Нет, нужен другой вариант»."
|
||||
}
|
||||
if item.ResponseOutcome != "" {
|
||||
return "Ответ записан: " + string(item.ResponseOutcome)
|
||||
}
|
||||
return ""
|
||||
}
|
||||
if item.State == continuity.AttentionDelivered || item.State == continuity.AttentionPending || item.State == continuity.AttentionFailed {
|
||||
return "Можно ответить: «Готово», «Отложи на 10 минут» или «Отмени»."
|
||||
}
|
||||
@@ -121,5 +178,8 @@ func humanAttentionSource(kind continuity.AttentionSourceKind) string {
|
||||
if kind == continuity.AttentionSourceProspectiveReminder {
|
||||
return "напоминание"
|
||||
}
|
||||
if kind == continuity.AttentionSourceAgentDelegation {
|
||||
return "задача coding-agent"
|
||||
}
|
||||
return "событие Домового"
|
||||
}
|
||||
|
||||
@@ -19,7 +19,9 @@ import (
|
||||
"git.cin.su/m/Assistant/contracts/continuity"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
"git.cin.su/m/Assistant/contracts/interaction"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
|
||||
workdomain "git.cin.su/m/Assistant/modules/work/domain"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
@@ -33,6 +35,11 @@ type continuityResponseClient struct {
|
||||
client *http.Client
|
||||
}
|
||||
|
||||
type continuityAttentionClient struct {
|
||||
baseURL *url.URL
|
||||
client *http.Client
|
||||
}
|
||||
|
||||
func newContinuityReminderClient(rawURL string, client *http.Client) (continuityReminderClient, error) {
|
||||
base, err := url.Parse(rawURL)
|
||||
if err != nil || base.Scheme == "" || base.Host == "" {
|
||||
@@ -55,6 +62,17 @@ func newContinuityResponseClient(rawURL string, client *http.Client) (continuity
|
||||
return continuityResponseClient{baseURL: base, client: client}, nil
|
||||
}
|
||||
|
||||
func newContinuityAttentionClient(rawURL string, client *http.Client) (continuityAttentionClient, error) {
|
||||
base, err := url.Parse(rawURL)
|
||||
if err != nil || base.Scheme == "" || base.Host == "" {
|
||||
return continuityAttentionClient{}, fmt.Errorf("invalid Continuity Runtime URL")
|
||||
}
|
||||
if client == nil {
|
||||
client = http.DefaultClient
|
||||
}
|
||||
return continuityAttentionClient{baseURL: base, client: client}, nil
|
||||
}
|
||||
|
||||
func (c continuityReminderClient) Schedule(ctx context.Context, authorization string, request continuity.ScheduleReminderRequest) (continuity.ScheduleReminderResult, error) {
|
||||
target := *c.baseURL
|
||||
target.Path = "/v1/creator/reminders"
|
||||
@@ -114,6 +132,37 @@ func (c continuityResponseClient) Respond(ctx context.Context, authorization str
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (c continuityAttentionClient) Create(ctx context.Context, authorization string, request continuity.CreateAttentionRequest) (continuity.AttentionItem, error) {
|
||||
target := *c.baseURL
|
||||
target.Path = "/v1/creator/attention"
|
||||
payload, err := json.Marshal(request)
|
||||
if err != nil {
|
||||
return continuity.AttentionItem{}, err
|
||||
}
|
||||
upstream, err := http.NewRequestWithContext(ctx, http.MethodPost, target.String(), bytes.NewReader(payload))
|
||||
if err != nil {
|
||||
return continuity.AttentionItem{}, err
|
||||
}
|
||||
upstream.Header.Set("Content-Type", "application/json")
|
||||
upstream.Header.Set("Authorization", authorization)
|
||||
response, err := c.client.Do(upstream)
|
||||
if err != nil {
|
||||
return continuity.AttentionItem{}, err
|
||||
}
|
||||
defer response.Body.Close()
|
||||
if response.StatusCode != http.StatusCreated {
|
||||
return continuity.AttentionItem{}, fmt.Errorf("continuity attention status %d", response.StatusCode)
|
||||
}
|
||||
var result continuity.AttentionItem
|
||||
if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
|
||||
return continuity.AttentionItem{}, err
|
||||
}
|
||||
if result.ID == "" || result.SourceKind == "" {
|
||||
return continuity.AttentionItem{}, fmt.Errorf("invalid attention result")
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func resolveChatCapability(ctx context.Context, repository *postgres.CapabilityRepository, kind capability.CapabilityKind, session identity.CreatorSession, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance, now time.Time) (capability.CapabilityResolution, error) {
|
||||
requirementID, err := ids.New()
|
||||
if err != nil {
|
||||
@@ -127,6 +176,7 @@ func resolveChatCapability(ctx context.Context, repository *postgres.CapabilityR
|
||||
OriginalIntentID: capability.OriginalIntentRef(intent.ID),
|
||||
SourceUtteranceID: capability.SourceUtteranceRef(utterance.ID),
|
||||
RequiredConstraints: []capability.DataConstraint{capability.DataConstraintLocalOnly},
|
||||
AllowCanary: allowCanaryForChatCapability(kind),
|
||||
AuthorityContextRef: capability.AuthorityPolicyCreatorDirectiveV1,
|
||||
ObservedAtUnixMillis: now.UnixMilli(),
|
||||
}
|
||||
@@ -144,6 +194,82 @@ func resolveChatCapability(ctx context.Context, repository *postgres.CapabilityR
|
||||
return resolution, err
|
||||
}
|
||||
|
||||
func allowCanaryForChatCapability(kind capability.CapabilityKind) bool {
|
||||
switch kind {
|
||||
case capability.CapabilityKindModifyCode, capability.CapabilityKindRunTests, capability.CapabilityKindInspectProject:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
type createdDelegation struct {
|
||||
Delegation work.Delegation
|
||||
Run work.AgentRun
|
||||
}
|
||||
|
||||
func maybeCreateAgentDelegation(ctx context.Context, workRepository *postgres.WorkRepository, capabilityRepository *postgres.CapabilityRepository, session identity.CreatorSession, conversation interaction.Conversation, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance, planning work.PlanningResult, now time.Time) (*createdDelegation, capability.CapabilityResolution, error) {
|
||||
requirement, ok := primarySoftwareRequirement(planning.Candidate.Requirements)
|
||||
if !ok {
|
||||
return nil, capability.CapabilityResolution{}, nil
|
||||
}
|
||||
resolution, err := resolveChatCapability(ctx, capabilityRepository, requirement.CapabilityKind, session, intent, utterance, now)
|
||||
if err != nil {
|
||||
return nil, resolution, err
|
||||
}
|
||||
if len(resolution.Eligible) == 0 || resolution.Eligible[0].Implementation.Kind != capability.ImplementationAgent {
|
||||
return nil, resolution, capabilitydomain.ErrNoCapabilityImplementation
|
||||
}
|
||||
started, err := workdomain.StartDelegation(workdomain.DelegationRequest{
|
||||
Goal: planning.Goal,
|
||||
Plan: planning.Plan,
|
||||
Candidate: planning.Candidate,
|
||||
Requirement: requirement,
|
||||
Implementation: resolution.Eligible[0].Implementation,
|
||||
ConversationID: work.ConversationRef(conversation.ID),
|
||||
OriginalIntentText: intent.Text,
|
||||
ContextSummary: planning.Candidate.Summary,
|
||||
ContextRefs: []string{"interaction:intent:" + string(intent.ID), "interaction:utterance:" + string(utterance.ID), "work:plan:" + string(planning.Plan.ID)},
|
||||
VerificationSummary: "verify through changed files, relevant tests, and explicit run evidence before work completion",
|
||||
DerivedInstruction: buildSoftwareAgentInstruction(planning, intent, utterance),
|
||||
StartedAt: now,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, capability.CapabilityResolution{}, err
|
||||
}
|
||||
if err := workRepository.SaveDelegationBundle(ctx, started.Delegation, started.Run); err != nil {
|
||||
return nil, capability.CapabilityResolution{}, err
|
||||
}
|
||||
return &createdDelegation{Delegation: started.Delegation, Run: started.Run}, resolution, nil
|
||||
}
|
||||
|
||||
func primarySoftwareRequirement(values []work.CapabilityRequirement) (work.CapabilityRequirement, bool) {
|
||||
for _, requirement := range values {
|
||||
switch requirement.CapabilityKind {
|
||||
case capability.CapabilityKindModifyCode, capability.CapabilityKindRunTests, capability.CapabilityKindInspectProject:
|
||||
return requirement, true
|
||||
}
|
||||
}
|
||||
return work.CapabilityRequirement{}, false
|
||||
}
|
||||
|
||||
func buildSoftwareAgentInstruction(planning work.PlanningResult, intent interaction.OriginalHumanIntent, utterance interaction.HumanUtterance) string {
|
||||
steps := make([]string, 0, len(planning.Candidate.Steps))
|
||||
for _, step := range planning.Candidate.Steps {
|
||||
if step.Description != "" {
|
||||
steps = append(steps, step.Description)
|
||||
}
|
||||
}
|
||||
return strings.TrimSpace(strings.Join([]string{
|
||||
"Human asked: " + strings.TrimSpace(intent.Text),
|
||||
"Original utterance: " + strings.TrimSpace(utterance.Content),
|
||||
"Desired outcome: " + planning.Goal.DesiredOutcome,
|
||||
"Plan summary: " + planning.Candidate.Summary,
|
||||
"Verification: run relevant tests and keep explicit evidence before claiming completion.",
|
||||
"Steps: " + strings.Join(steps, " | "),
|
||||
}, "\n"))
|
||||
}
|
||||
|
||||
func observeCapabilityUsage(ctx context.Context, repository *postgres.CapabilityRepository, selected capability.ResolvedCapabilityImplementation, requirement capability.CapabilityResolutionRequirement, outcome capability.UsageOutcomeClass, outcomeRef string, started time.Time, now time.Time) (capability.CapabilityUsageObservationID, error) {
|
||||
id, err := ids.New()
|
||||
if err != nil {
|
||||
|
||||
@@ -9,9 +9,11 @@ import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/capability"
|
||||
"git.cin.su/m/Assistant/contracts/continuity"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
"git.cin.su/m/Assistant/contracts/interaction"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
)
|
||||
|
||||
func TestBuildReminderRequestParsesTomorrowAtTen(t *testing.T) {
|
||||
@@ -72,3 +74,29 @@ func TestReminderSummaryRemovesSchedulingWords(t *testing.T) {
|
||||
t.Fatalf("summary = %q", summary)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBuildSoftwareAgentInstructionKeepsHumanIntentSeparateFromDerivedContext(t *testing.T) {
|
||||
instruction := buildSoftwareAgentInstruction(
|
||||
work.PlanningResult{
|
||||
Goal: work.Goal{DesiredOutcome: "fix chat wording"},
|
||||
Candidate: work.PlanCandidate{Summary: "accepted deterministic software change plan", Steps: []work.PlanStep{{Description: "Inspect chat surface"}, {Description: "Change copy"}, {Description: "Run tests"}}},
|
||||
},
|
||||
interaction.OriginalHumanIntent{ID: "intent-1", Text: "Исправь текст в чате Assistant."},
|
||||
interaction.HumanUtterance{ID: "utterance-1", Content: "Исправь текст в чате Assistant."},
|
||||
)
|
||||
if !strings.Contains(instruction, "Human asked: Исправь текст в чате Assistant.") {
|
||||
t.Fatalf("instruction must preserve human intent: %q", instruction)
|
||||
}
|
||||
if !strings.Contains(instruction, "Verification: run relevant tests") || !strings.Contains(instruction, "Plan summary: accepted deterministic software change plan") {
|
||||
t.Fatalf("instruction must include derived execution context: %q", instruction)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAllowCanaryForChatCapabilityIsLimitedToSoftwareEngineeringPath(t *testing.T) {
|
||||
if !allowCanaryForChatCapability(capability.CapabilityKindModifyCode) || !allowCanaryForChatCapability(capability.CapabilityKindRunTests) || !allowCanaryForChatCapability(capability.CapabilityKindInspectProject) {
|
||||
t.Fatal("software-engineering capabilities must allow canary implementations")
|
||||
}
|
||||
if allowCanaryForChatCapability(capability.CapabilityKindScheduleReminder) {
|
||||
t.Fatal("non software-engineering capability must not implicitly allow canary")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@ package main
|
||||
import (
|
||||
"context"
|
||||
"log"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
@@ -68,6 +69,20 @@ type capabilityLearningInput struct {
|
||||
At time.Time
|
||||
}
|
||||
|
||||
type delegationLearningInput struct {
|
||||
Intent interaction.OriginalHumanIntent
|
||||
Utterance interaction.HumanUtterance
|
||||
DelegationID string
|
||||
RunID string
|
||||
ImplementationID capability.CapabilityImplementationID
|
||||
OutcomeRef string
|
||||
VerificationRefs []epistemics.EvidenceRef
|
||||
Verified bool
|
||||
ExecutionWindows int
|
||||
HumanBlocked bool
|
||||
At time.Time
|
||||
}
|
||||
|
||||
func (r learningRecorder) recordReminderResponse(ctx context.Context, input reminderResponseLearningInput) {
|
||||
if r.epistemics == nil || r.capability == nil || input.Intent.ID == "" || input.Utterance.ID == "" || input.Result.Response.ID == "" {
|
||||
return
|
||||
@@ -200,6 +215,42 @@ func (r learningRecorder) recordCapabilityUse(ctx context.Context, input capabil
|
||||
r.saveExperienceAndReflection(ctx, experience)
|
||||
}
|
||||
|
||||
func (r learningRecorder) recordDelegationOutcome(ctx context.Context, input delegationLearningInput) {
|
||||
if r.epistemics == nil || input.Intent.ID == "" || input.Utterance.ID == "" || input.ImplementationID == "" {
|
||||
return
|
||||
}
|
||||
actual := epistemics.OutcomeSuccess
|
||||
confidence := int64(950)
|
||||
if !input.Verified {
|
||||
actual = epistemics.OutcomeFailed
|
||||
confidence = 850
|
||||
}
|
||||
detailParts := []string{"delegation outcome recorded"}
|
||||
if input.ExecutionWindows > 1 {
|
||||
detailParts = append(detailParts, "execution-window-continuations="+strconv.Itoa(input.ExecutionWindows-1))
|
||||
}
|
||||
if input.HumanBlocked {
|
||||
detailParts = append(detailParts, "human-blocker-occurred")
|
||||
}
|
||||
experience := epistemics.ExperienceRecord{
|
||||
SourceKind: epistemics.ExperienceSourceCapability,
|
||||
OriginalIntentID: epistemics.OriginalIntentRef(input.Intent.ID),
|
||||
SourceUtteranceID: epistemics.SourceUtteranceRef(input.Utterance.ID),
|
||||
ContextRefs: contextRefs("work:delegation:"+input.DelegationID, "work:run:"+input.RunID),
|
||||
HelpMethod: epistemics.HelpMethodCapabilityExecution,
|
||||
HelpMethodRef: "work:agent-delegation-v1",
|
||||
CapabilityImplementationRef: epistemics.CapabilityImplementationRef(input.ImplementationID),
|
||||
ExpectedOutcome: epistemics.OutcomeSuccess,
|
||||
ActualOutcome: actual,
|
||||
OutcomeRef: input.OutcomeRef,
|
||||
OutcomeDetail: strings.Join(detailParts, "; "),
|
||||
VerificationEvidence: input.VerificationRefs,
|
||||
ConfidenceMillis: confidence,
|
||||
RecordedAtUnixMillis: input.At.UnixMilli(),
|
||||
}
|
||||
r.saveExperienceAndReflection(ctx, experience)
|
||||
}
|
||||
|
||||
func (r learningRecorder) saveExperienceAndReflection(ctx context.Context, value epistemics.ExperienceRecord) (epistemics.ExperienceRecord, bool) {
|
||||
value, err := epistemicsdomain.NewExperienceRecord(value)
|
||||
if err != nil {
|
||||
|
||||
@@ -107,6 +107,10 @@ func main() {
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
attentionClient, err := newContinuityAttentionClient(envOr("CONTINUITY_RUNTIME_URL", "http://continuity-runtime:8081"), &http.Client{Timeout: 5 * time.Second})
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
learning := learningRecorder{epistemics: epistemicsRepository, capability: capabilityRepository}
|
||||
mux := http.NewServeMux()
|
||||
authenticateCreator := func(w http.ResponseWriter, r *http.Request) (identity.CreatorSession, bool) {
|
||||
@@ -327,6 +331,9 @@ func main() {
|
||||
planningReply = responseResult.Reply
|
||||
needsCognition = false
|
||||
learning.recordReminderResponse(r.Context(), reminderResponseLearningInput{Utterance: utterance, Intent: intent, Result: responseResult, At: now})
|
||||
if resumed, err := continueDelegationFromHumanResponse(r.Context(), workRepository, responseResult.Response, now); err == nil && resumed {
|
||||
planningReply = "Принял. Продолжаю ту же задачу coding-agent без потери контекста."
|
||||
}
|
||||
} else if responseErr == nil && looksLikeUnsupportedContinuation(utterance.Content, responseResult) {
|
||||
learning.recordFastPathDecline(r.Context(), fastPathDeclineLearningInput{Utterance: utterance, Intent: intent, Result: responseResult, Reason: declineReasonForResponse(responseResult), At: now})
|
||||
}
|
||||
@@ -365,6 +372,8 @@ func main() {
|
||||
var capabilityStatus capability.CapabilityResolutionStatus
|
||||
var capabilityKind capability.CapabilityKind
|
||||
var capabilityGapID capability.CapabilityGapID
|
||||
var delegationID work.DelegationID
|
||||
var delegationState work.DelegationState
|
||||
var reminder *continuity.ProspectiveItem
|
||||
if helpPath.Kind == work.HelpPathDirectCapability && len(helpPath.SuggestedCapabilityKinds) > 0 {
|
||||
capabilityKind = helpPath.SuggestedCapabilityKinds[0]
|
||||
@@ -423,6 +432,18 @@ func main() {
|
||||
planningReply = planning.Reply
|
||||
workPlanned = true
|
||||
needsCognition = false
|
||||
if created, resolution, createErr := maybeCreateAgentDelegation(r.Context(), workRepository, capabilityRepository, session, conversation, intent, utterance, planning, now); createErr == nil && created != nil {
|
||||
delegationID = created.Delegation.ID
|
||||
delegationState = created.Delegation.State
|
||||
capabilityKind = created.Delegation.CapabilityKind
|
||||
capabilityStatus = resolution.Status
|
||||
planningReply = "Понял задачу. Я собрал work item, выбрал coding-agent в CANARY-режиме и создал delegation. Буду вести её как отдельный run с checkpoint/resume, без потери исходного human intent."
|
||||
} else if resolution.Gap != nil {
|
||||
capabilityKind = resolution.Requirement.CapabilityKind
|
||||
capabilityStatus = resolution.Status
|
||||
capabilityGapID = resolution.Gap.ID
|
||||
planningReply = planningReply + " Для coding delegation подходящий agent implementation сейчас недоступен, поэтому я сохранил план без ложного запуска."
|
||||
}
|
||||
}
|
||||
response := interaction.ChatMessageResponse{
|
||||
ConversationID: conversation.ID,
|
||||
@@ -440,6 +461,8 @@ func main() {
|
||||
CapabilityStatus: capabilityStatus,
|
||||
CapabilityKind: capabilityKind,
|
||||
CapabilityGapID: capabilityGapID,
|
||||
DelegationID: string(delegationID),
|
||||
DelegationState: string(delegationState),
|
||||
Reminder: reminder,
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
@@ -447,6 +470,210 @@ func main() {
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_ = json.NewEncoder(w).Encode(response)
|
||||
})
|
||||
mux.HandleFunc("GET /v1/creator/delegations/{id}", func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := authenticateCreator(w, r); !ok {
|
||||
return
|
||||
}
|
||||
value, err := workRepository.LoadDelegation(r.Context(), work.DelegationID(r.PathValue("id")))
|
||||
if err != nil {
|
||||
http.Error(w, "delegation not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(value)
|
||||
})
|
||||
mux.HandleFunc("GET /v1/creator/delegations/{id}/latest-checkpoint", func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := authenticateCreator(w, r); !ok {
|
||||
return
|
||||
}
|
||||
value, err := workRepository.LatestAgentCheckpoint(r.Context(), work.DelegationID(r.PathValue("id")))
|
||||
if err != nil {
|
||||
http.Error(w, "checkpoint not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(value)
|
||||
})
|
||||
mux.HandleFunc("POST /v1/creator/delegations/{id}/runs/{run}/checkpoints", func(w http.ResponseWriter, r *http.Request) {
|
||||
session, ok := authenticateCreator(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var request struct {
|
||||
BlockerClass work.AgentBlockerClass
|
||||
CompletedSummary string
|
||||
RemainingSummary string
|
||||
TestSummary string
|
||||
BranchName string
|
||||
CommitHash string
|
||||
NextStep string
|
||||
ArtifactRefs []work.EvidenceRef
|
||||
RecordedAtUnixMillis int64
|
||||
}
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(&request); err != nil {
|
||||
http.Error(w, "invalid checkpoint", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
run, err := workRepository.LoadAgentRun(r.Context(), work.AgentRunID(r.PathValue("run")))
|
||||
if err != nil || run.DelegationID != work.DelegationID(r.PathValue("id")) {
|
||||
http.Error(w, "run not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
updatedRun, checkpoint, err := workdomain.CheckpointRun(run, request.BlockerClass, request.CompletedSummary, request.RemainingSummary, request.TestSummary, request.BranchName, request.CommitHash, request.NextStep, request.ArtifactRefs, time.UnixMilli(request.RecordedAtUnixMillis))
|
||||
if err != nil {
|
||||
http.Error(w, "invalid checkpoint", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if err := workRepository.SaveAgentCheckpoint(r.Context(), updatedRun, checkpoint); err != nil {
|
||||
http.Error(w, "save checkpoint", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
if request.BlockerClass == work.AgentBlockerHumanDecisionRequired {
|
||||
delegation, err := workRepository.LoadDelegation(r.Context(), run.DelegationID)
|
||||
if err == nil {
|
||||
_, _ = attentionClient.Create(r.Context(), r.Header.Get("Authorization"), continuity.CreateAttentionRequest{
|
||||
OwnerPrincipalID: session.PrincipalID,
|
||||
ScopeID: authority.ScopeID("domovoy-global-scope"),
|
||||
SourceKind: continuity.AttentionSourceAgentDelegation,
|
||||
SourceExternalRef: delegationAttentionRef(delegation.ID),
|
||||
Level: continuity.AttentionActionRequired,
|
||||
Summary: "Нужен твой выбор по задаче coding-agent: " + firstNonEmpty(request.RemainingSummary, delegation.DesiredOutcome),
|
||||
DueAtUnixMillis: checkpoint.RecordedAtUnixMillis,
|
||||
CreatedAtUnixMillis: checkpoint.RecordedAtUnixMillis,
|
||||
})
|
||||
}
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_ = json.NewEncoder(w).Encode(checkpoint)
|
||||
})
|
||||
mux.HandleFunc("POST /v1/creator/delegations/{id}/runs/{run}/results", func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := authenticateCreator(w, r); !ok {
|
||||
return
|
||||
}
|
||||
var request struct {
|
||||
Summary string
|
||||
OutcomeRef string
|
||||
VerificationSummary string
|
||||
ArtifactRefs []work.EvidenceRef
|
||||
RecordedAtUnixMillis int64
|
||||
}
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(&request); err != nil {
|
||||
http.Error(w, "invalid result", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
run, err := workRepository.LoadAgentRun(r.Context(), work.AgentRunID(r.PathValue("run")))
|
||||
if err != nil || run.DelegationID != work.DelegationID(r.PathValue("id")) {
|
||||
http.Error(w, "run not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
updatedRun, result, err := workdomain.CompleteRun(run, request.Summary, request.OutcomeRef, request.VerificationSummary, request.ArtifactRefs, time.UnixMilli(request.RecordedAtUnixMillis))
|
||||
if err != nil {
|
||||
http.Error(w, "invalid result", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if err := workRepository.SaveAgentResult(r.Context(), updatedRun, result); err != nil {
|
||||
http.Error(w, "save result", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_ = json.NewEncoder(w).Encode(result)
|
||||
})
|
||||
mux.HandleFunc("POST /v1/creator/delegations/{id}/resume", func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := authenticateCreator(w, r); !ok {
|
||||
return
|
||||
}
|
||||
delegation, err := workRepository.LoadDelegation(r.Context(), work.DelegationID(r.PathValue("id")))
|
||||
if err != nil {
|
||||
http.Error(w, "delegation not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
run, err := workRepository.LoadAgentRun(r.Context(), delegation.LatestRunID)
|
||||
if err != nil {
|
||||
http.Error(w, "run not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
checkpoint, err := workRepository.LatestAgentCheckpoint(r.Context(), delegation.ID)
|
||||
if err != nil {
|
||||
http.Error(w, "checkpoint not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
updatedDelegation, resumedRun, err := workdomain.ResumeDelegationRun(delegation, run, checkpoint, time.Now())
|
||||
if err != nil {
|
||||
http.Error(w, "resume not allowed", http.StatusConflict)
|
||||
return
|
||||
}
|
||||
if err := workRepository.SaveResumedRun(r.Context(), updatedDelegation, resumedRun); err != nil {
|
||||
http.Error(w, "save resumed run", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_ = json.NewEncoder(w).Encode(resumedRun)
|
||||
})
|
||||
mux.HandleFunc("POST /v1/creator/delegations/{id}/verify", func(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := authenticateCreator(w, r); !ok {
|
||||
return
|
||||
}
|
||||
var request struct {
|
||||
Verified bool
|
||||
Summary string
|
||||
EvidenceRefs []work.EvidenceRef
|
||||
RecordedAtUnixMillis int64
|
||||
}
|
||||
decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 32<<10))
|
||||
decoder.DisallowUnknownFields()
|
||||
if err := decoder.Decode(&request); err != nil || request.RecordedAtUnixMillis < 1 {
|
||||
http.Error(w, "invalid verification", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
delegation, err := workRepository.LoadDelegation(r.Context(), work.DelegationID(r.PathValue("id")))
|
||||
if err != nil {
|
||||
http.Error(w, "delegation not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
run, err := workRepository.LoadAgentRun(r.Context(), delegation.LatestRunID)
|
||||
if err != nil {
|
||||
http.Error(w, "run not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
result, err := workRepository.LatestAgentResult(r.Context(), delegation.ID)
|
||||
if err != nil {
|
||||
http.Error(w, "result not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
updatedDelegation, verification, err := workdomain.VerifyDelegationResult(delegation, run, result, request.Verified, request.Summary, request.EvidenceRefs, time.UnixMilli(request.RecordedAtUnixMillis))
|
||||
if err != nil {
|
||||
http.Error(w, "invalid verification", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if err := workRepository.SaveDelegationVerification(r.Context(), updatedDelegation, verification); err != nil {
|
||||
http.Error(w, "save verification", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
runCount, _ := workRepository.CountAgentRuns(r.Context(), delegation.ID)
|
||||
learning.recordDelegationOutcome(r.Context(), delegationLearningInput{
|
||||
Intent: interaction.OriginalHumanIntent{ID: interaction.OriginalHumanIntentID(delegation.SourceIntentID), Text: delegation.DesiredOutcome},
|
||||
Utterance: interaction.HumanUtterance{ID: interaction.HumanUtteranceID(delegation.SourceUtteranceID), Content: delegation.DesiredOutcome},
|
||||
DelegationID: string(delegation.ID),
|
||||
RunID: string(run.ID),
|
||||
ImplementationID: run.ImplementationID,
|
||||
OutcomeRef: result.OutcomeRef,
|
||||
VerificationRefs: evidenceRefsToEpistemics(request.EvidenceRefs),
|
||||
Verified: request.Verified,
|
||||
ExecutionWindows: runCount,
|
||||
HumanBlocked: false,
|
||||
At: time.UnixMilli(request.RecordedAtUnixMillis),
|
||||
})
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_ = json.NewEncoder(w).Encode(verification)
|
||||
})
|
||||
mux.HandleFunc("GET /v1/principal-bindings/{actor}/{principal}", func(w http.ResponseWriter, r *http.Request) {
|
||||
binding, err := identityRepository.LoadBinding(r.Context(), identity.ActorID(r.PathValue("actor")), identity.PrincipalID(r.PathValue("principal")))
|
||||
if err != nil {
|
||||
@@ -859,3 +1086,54 @@ func humanCapabilityList(kinds []capability.CapabilityKind) string {
|
||||
}
|
||||
return strings.Join(labels, ", ")
|
||||
}
|
||||
|
||||
func delegationAttentionRef(id work.DelegationID) string {
|
||||
return "work:delegation:" + string(id)
|
||||
}
|
||||
|
||||
func continueDelegationFromHumanResponse(ctx context.Context, repository *postgres.WorkRepository, response continuity.HumanResponse, now time.Time) (bool, error) {
|
||||
if response.Operation != continuity.ResponseContinue || !strings.HasPrefix(response.TargetExternalRef, "work:delegation:") {
|
||||
return false, nil
|
||||
}
|
||||
delegationID := work.DelegationID(strings.TrimPrefix(response.TargetExternalRef, "work:delegation:"))
|
||||
delegation, err := repository.LoadDelegation(ctx, delegationID)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
run, err := repository.LoadAgentRun(ctx, delegation.LatestRunID)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
checkpoint, err := repository.LatestAgentCheckpoint(ctx, delegationID)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
updatedDelegation, resumedRun, err := workdomain.ResumeDelegationRun(delegation, run, checkpoint, now)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
if err := repository.SaveResumedRun(ctx, updatedDelegation, resumedRun); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func firstNonEmpty(values ...string) string {
|
||||
for _, value := range values {
|
||||
if strings.TrimSpace(value) != "" {
|
||||
return strings.TrimSpace(value)
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func evidenceRefsToEpistemics(values []work.EvidenceRef) []epistemics.EvidenceRef {
|
||||
result := make([]epistemics.EvidenceRef, 0, len(values))
|
||||
for _, value := range values {
|
||||
if strings.TrimSpace(string(value)) == "" {
|
||||
continue
|
||||
}
|
||||
result = append(result, epistemics.EvidenceRef(value))
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
@@ -154,6 +154,8 @@ type browserChatResponse struct {
|
||||
WorkPlanned bool `json:"work_planned"`
|
||||
CapabilityStatus string `json:"capability_status"`
|
||||
CapabilityKind string `json:"capability_kind"`
|
||||
DelegationID string `json:"delegation_id"`
|
||||
DelegationState string `json:"delegation_state"`
|
||||
ReminderScheduled bool `json:"reminder_scheduled"`
|
||||
}
|
||||
|
||||
@@ -353,7 +355,22 @@ func (g *gateway) handleChatMessage(w http.ResponseWriter, r *http.Request) {
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.Header().Set("Cache-Control", "no-store")
|
||||
_ = json.NewEncoder(w).Encode(browserChatResponse{ConversationID: string(saved.ConversationID), UtteranceID: string(saved.UtteranceID), SpeechAct: string(saved.SpeechAct), ReplyText: reply, Cognition: cognition, ActiveFocus: saved.ActiveProjectName, ProjectProvenance: string(saved.ProjectProvenance), Clarification: string(saved.Clarification), WorkPlanned: saved.WorkPlanned, CapabilityStatus: string(saved.CapabilityStatus), CapabilityKind: string(saved.CapabilityKind), ReminderScheduled: saved.Reminder != nil})
|
||||
_ = json.NewEncoder(w).Encode(browserChatResponse{
|
||||
ConversationID: string(saved.ConversationID),
|
||||
UtteranceID: string(saved.UtteranceID),
|
||||
SpeechAct: string(saved.SpeechAct),
|
||||
ReplyText: reply,
|
||||
Cognition: cognition,
|
||||
ActiveFocus: saved.ActiveProjectName,
|
||||
ProjectProvenance: string(saved.ProjectProvenance),
|
||||
Clarification: string(saved.Clarification),
|
||||
WorkPlanned: saved.WorkPlanned,
|
||||
CapabilityStatus: string(saved.CapabilityStatus),
|
||||
CapabilityKind: string(saved.CapabilityKind),
|
||||
DelegationID: saved.DelegationID,
|
||||
DelegationState: saved.DelegationState,
|
||||
ReminderScheduled: saved.Reminder != nil,
|
||||
})
|
||||
}
|
||||
|
||||
func asksAttention(message string) bool {
|
||||
|
||||
@@ -62,11 +62,31 @@ async function api(path, options = {}) {
|
||||
|
||||
function humanMeta(result) {
|
||||
if (result.reminder_scheduled) return "Напоминание сохранено. Я вернусь к нему сам.";
|
||||
if (result.delegation_id && result.delegation_state) return `Передал в coding-agent: ${humanDelegationState(result.delegation_state)}.`;
|
||||
if (result.capability_status && result.capability_status !== "AVAILABLE") return "Возможность пока не подключена.";
|
||||
if (result.work_planned) return "Я разложил это как работу.";
|
||||
return "";
|
||||
}
|
||||
|
||||
function humanDelegationState(state) {
|
||||
switch (state) {
|
||||
case "RUNNING":
|
||||
return "работа запущена";
|
||||
case "WAITING":
|
||||
return "ожидаю следующий шаг";
|
||||
case "BLOCKED":
|
||||
return "нужно решение человека";
|
||||
case "VERIFYING":
|
||||
return "результат проверяется";
|
||||
case "COMPLETED":
|
||||
return "работа завершена";
|
||||
case "FAILED":
|
||||
return "run завершился ошибкой";
|
||||
default:
|
||||
return state.toLowerCase();
|
||||
}
|
||||
}
|
||||
|
||||
function renderHistory() {
|
||||
if (!historyList) return;
|
||||
historyList.replaceChildren();
|
||||
|
||||
Reference in New Issue
Block a user