DEV-000069 general agent delegation codex bridge foundation
CI / test (push) Successful in 20s
CI / test (pull_request) Successful in 20s

This commit is contained in:
m
2026-08-17 20:07:14 +03:00
parent d870e1361d
commit b3491520bd
21 changed files with 1914 additions and 20 deletions
+60
View File
@@ -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 "событие Домового"
}
+126
View File
@@ -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 {
+28
View File
@@ -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")
}
}
+51
View File
@@ -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 {
+278
View File
@@ -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
}
+18 -1
View File
@@ -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 {
+20
View File
@@ -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();