DEV-000072 semantic interpretation deferral boundary
CI / test (push) Successful in 18s
CI / test (pull_request) Successful in 17s

This commit is contained in:
m
2026-08-17 23:02:00 +03:00
parent 64870798b9
commit ce666bbc43
22 changed files with 1773 additions and 123 deletions
+137
View File
@@ -0,0 +1,137 @@
package main
import (
"encoding/json"
"fmt"
"net/http"
"strings"
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/contracts/cognitive"
)
func (g cognitiveGateway) interpretationHandler(w http.ResponseWriter, r *http.Request) {
var request cognitive.GatewayInterpretationRequest
if !decodeJSON(w, r, 80<<10, &request) {
return
}
if request.Version != cognitive.CreatorAdvisoryV1 || request.RequestID == "" || request.ActorID == "" || request.PrincipalID == "" || request.ScopeID == "" || strings.TrimSpace(request.Message) == "" || request.MaxOutputBytes < 1 {
http.Error(w, "invalid interpretation request", http.StatusBadRequest)
return
}
maxOutputBytes := request.MaxOutputBytes
if g.allowCanary && g.canaryMaxOutputBytes > 0 && maxOutputBytes > g.canaryMaxOutputBytes {
maxOutputBytes = g.canaryMaxOutputBytes
}
requirement := capability.CognitiveRequirement{
CapabilityID: creatorAdvisoryCapabilityID,
OwnerPrincipalID: request.PrincipalID,
DataPolicy: request.DataPolicy,
RequiredModalities: []capability.ModelModality{capability.ModalityText},
RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory},
AllowCanary: g.allowCanary,
InputBytes: int64(len(request.Message)),
MaxOutputBytes: int64(maxOutputBytes),
}
selected, err := g.resolver.Resolve(r.Context(), requirement)
if err != nil {
writeInterpretationResponse(w, cognitive.GatewayInterpretationResponse{Version: request.Version, RequestID: request.RequestID, FinishReason: cognitive.FinishProviderUnavailable})
return
}
provider := g.provider(selected)
if provider == nil {
writeInterpretationResponse(w, cognitive.GatewayInterpretationResponse{Version: request.Version, RequestID: request.RequestID, FinishReason: cognitive.FinishProviderUnavailable})
return
}
invocation := cognitive.AdvisoryRequest{
Version: request.Version,
RequestID: request.RequestID,
ActorID: request.ActorID,
PrincipalID: request.PrincipalID,
ScopeID: request.ScopeID,
Message: interpretationPrompt(request),
Locale: request.Locale,
MaxOutputBytes: maxOutputBytes,
ProviderBindingID: selected.Binding.ID,
ProviderBindingRevision: selected.Binding.Revision,
ProviderInstanceID: selected.Provider.ID,
ModelDescriptorID: selected.Model.ID,
ProviderModelID: selected.Model.ProviderModelID,
}
started := g.now()
response, invokeErr := provider.Advise(r.Context(), invocation)
if invokeErr != nil {
response = cognitive.AdvisoryResponse{Version: request.Version, RequestID: request.RequestID, ProviderBindingID: selected.Binding.ID, ProviderBindingRevision: selected.Binding.Revision, FinishReason: cognitive.FinishInvalidProviderResponse}
}
g.observe(r.Context(), selected, response, started)
if response.FinishReason != cognitive.FinishCompleted {
writeInterpretationResponse(w, cognitive.GatewayInterpretationResponse{Version: request.Version, RequestID: request.RequestID, FinishReason: response.FinishReason, Usage: response.Usage})
return
}
candidate, ok := parseInterpretationCandidate(response.AdvisoryText)
if !ok {
writeInterpretationResponse(w, cognitive.GatewayInterpretationResponse{Version: request.Version, RequestID: request.RequestID, FinishReason: cognitive.FinishInvalidStructuredOutput, Usage: response.Usage})
return
}
writeInterpretationResponse(w, cognitive.GatewayInterpretationResponse{Version: request.Version, RequestID: request.RequestID, Candidate: candidate, FinishReason: cognitive.FinishCompleted, Usage: response.Usage})
}
func interpretationPrompt(request cognitive.GatewayInterpretationRequest) string {
projects := "none"
if len(request.ProjectNames) > 0 {
projects = strings.Join(request.ProjectNames, ", ")
}
return fmt.Sprintf(`Return only strict JSON with keys primary_speech_act, secondary_speech_act, confidence_millis, applicability, requested_outcome, needs_cognition, clarification, selection_reason, capability_hints.
Allowed speech acts: DIRECTIVE, ASSERTION, DECISION, PREFERENCE, QUESTION, HYPOTHESIS, CORRECTION, REQUEST_TO_INVESTIGATE, CONFIRMATION, REJECTION, CANCELLATION, CONVERSATIONAL, UNKNOWN.
Allowed applicability: APPLICABLE, LOW_CONFIDENCE, MIXED_INTENT, NEEDS_BROADER_INTERPRETATION, CLARIFICATION_REQUIRED.
Allowed clarification: NOT_REQUIRED or REQUIRED.
Capability hints may only contain known capability kinds like COGNITIVE_REASONING, MODIFY_CODE, RUN_TESTS, SEND_EMAIL, SCHEDULE_REMINDER, VERIFY_FACT, INSPECT_PROJECT, READ_DATABASE, QUERY_LOGS.
Interpret the human utterance semantically. Do not claim action execution. Do not treat punctuation alone as decisive. If uncertain, set applicability accordingly.
Message: %q
Deterministic primary: %s
Deterministic secondary: %s
Deterministic confidence: %d
Deterministic applicability: %s
Deterministic requested outcome: %q
Relevant project names: %s`, request.Message, request.DeterministicSpeechAct, request.DeterministicSecondary, request.DeterministicConfidence, request.DeterministicApplicability, request.RequestedOutcome, projects)
}
func parseInterpretationCandidate(text string) (cognitive.GatewayInterpretationCandidate, bool) {
start := strings.Index(text, "{")
end := strings.LastIndex(text, "}")
if start < 0 || end <= start {
return cognitive.GatewayInterpretationCandidate{}, false
}
var candidate cognitive.GatewayInterpretationCandidate
if err := json.Unmarshal([]byte(text[start:end+1]), &candidate); err != nil {
return cognitive.GatewayInterpretationCandidate{}, false
}
if !validSpeechAct(candidate.PrimarySpeechAct) || candidate.ConfidenceMillis < 0 || candidate.ConfidenceMillis > 1000 {
return cognitive.GatewayInterpretationCandidate{}, false
}
if candidate.SecondarySpeechAct != "" && !validSpeechAct(candidate.SecondarySpeechAct) {
return cognitive.GatewayInterpretationCandidate{}, false
}
switch candidate.Applicability {
case cognitive.InterpretationApplicable, cognitive.InterpretationLowConfidence, cognitive.InterpretationMixedIntent, cognitive.InterpretationNeedsBroader, cognitive.InterpretationClarificationRequired:
default:
return cognitive.GatewayInterpretationCandidate{}, false
}
if candidate.Clarification != "NOT_REQUIRED" && candidate.Clarification != "REQUIRED" {
return cognitive.GatewayInterpretationCandidate{}, false
}
return candidate, true
}
func validSpeechAct(value string) bool {
switch value {
case "DIRECTIVE", "ASSERTION", "DECISION", "PREFERENCE", "QUESTION", "HYPOTHESIS", "CORRECTION", "REQUEST_TO_INVESTIGATE", "CONFIRMATION", "REJECTION", "CANCELLATION", "CONVERSATIONAL", "UNKNOWN":
return true
}
return false
}
func writeInterpretationResponse(w http.ResponseWriter, response cognitive.GatewayInterpretationResponse) {
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(response)
}
@@ -0,0 +1,219 @@
package main
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"os"
"testing"
"time"
"git.cin.su/m/Assistant/adapters/models"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/contracts/cognitive"
"git.cin.su/m/Assistant/contracts/identity"
"git.cin.su/m/Assistant/contracts/interaction"
"git.cin.su/m/Assistant/contracts/situation"
interactiondomain "git.cin.su/m/Assistant/modules/interaction/domain"
)
func TestLiveInterpretationTrace(t *testing.T) {
if os.Getenv("ASSISTANT_LIVE_SEMANTIC_TRACE") != "1" {
t.Skip("set ASSISTANT_LIVE_SEMANTIC_TRACE=1 for live semantic/gateway/raw trace")
}
ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
defer cancel()
rawBase := envOr("LOCAL_CPU_PROVIDER_URL", "http://docker.cin.su:18082/v1")
rawModelID, err := firstRawModel(ctx, rawBase)
if err != nil {
t.Fatal(err)
}
cpuAdapter, err := models.NewOpenAICompatibleLocalAdapter(rawBase, nil)
if err != nil {
t.Fatal(err)
}
discovered, probe := cpuAdapter.Discover(ctx)
if probe.Health != capability.HealthAvailable || len(discovered) == 0 {
t.Fatalf("cpu discovery unavailable: probe=%+v models=%+v", probe, discovered)
}
selected := capability.ResolvedCognitiveBinding{
Binding: capability.CognitiveBinding{
ID: "trace-binding",
Revision: 1,
CapabilityID: "creator-advisory",
OwnerPrincipalID: "domovoy-creator-principal",
DataPolicy: capability.DataPolicyLocalOnly,
},
Provider: capability.ProviderInstance{
ID: "local-cpu-primary",
Revision: 1,
Kind: "openai-compatible-chat-v1",
EndpointRef: "local-cpu-primary-v1",
},
Model: capability.ModelDescriptor{
ID: capability.ModelDescriptorID("trace-model"),
Revision: 1,
ProviderModelID: discovered[0].ProviderModelID,
},
}
gateway := cognitiveGateway{
resolver: traceResolver{selected: selected},
providers: map[capability.ProviderKind][]providerRegistration{
"openai-compatible-chat-v1": {{
ProviderInstanceID: "local-cpu-primary",
Kind: "openai-compatible-chat-v1",
EndpointRef: "local-cpu-primary-v1",
Provider: cpuAdapter,
}},
},
now: time.Now,
allowCanary: true,
}
for _, message := range []string{"ты кто", "можешь расказать об утре"} {
conversation := interaction.Conversation{ID: "trace-conversation", ActorID: "trace-actor", PrincipalID: "domovoy-creator-principal", Channel: interaction.ChannelWebChat, State: interaction.ConversationOpen}
utterance, _, _, err := interactiondomain.NewHumanUtterance(conversation, interaction.ChatMessageRequest{Message: message}, time.Now())
if err != nil {
t.Fatal(err)
}
semantic, err := interactiondomain.InterpretUtterance(utterance, []situation.ProjectDescriptor{{ID: "assistant", DisplayName: "Assistant"}}, nil, time.Now())
if err != nil {
t.Fatal(err)
}
rawResponse, err := rawCompletion(ctx, rawBase, rawModelID, message)
if err != nil {
t.Fatal(err)
}
request := cognitive.GatewayInterpretationRequest{
Version: cognitive.CreatorAdvisoryV1,
RequestID: "trace-request",
ActorID: identity.ActorID("trace-actor"),
PrincipalID: identity.PrincipalID("domovoy-creator-principal"),
ScopeID: authority.ScopeID("domovoy-global-scope"),
Message: message,
Locale: "ru",
MaxOutputBytes: 4096,
DataPolicy: capability.DataPolicyLocalOnly,
DeterministicSpeechAct: string(semantic.Interpretation.SpeechAct),
DeterministicSecondary: string(semantic.Interpretation.SecondarySpeechAct),
DeterministicConfidence: semantic.Interpretation.ConfidenceMillis,
DeterministicApplicability: cognitive.InterpretationApplicability(semantic.Interpretation.Applicability),
RequestedOutcome: semantic.Interpretation.RequestedOutcome,
}
payload, _ := json.Marshal(request)
recorder := httptest.NewRecorder()
httpRequest := httptest.NewRequest(http.MethodPost, "/v1/interpretations", bytes.NewReader(payload))
gateway.interpretationHandler(recorder, httpRequest.WithContext(ctx))
if recorder.Code != http.StatusOK {
t.Fatalf("message=%q gateway status=%d body=%s", message, recorder.Code, recorder.Body.String())
}
var gatewayResponse cognitive.GatewayInterpretationResponse
if err := json.Unmarshal(recorder.Body.Bytes(), &gatewayResponse); err != nil {
t.Fatal(err)
}
if gatewayResponse.FinishReason != cognitive.FinishCompleted {
t.Fatalf("message=%q gateway finish=%s body=%s", message, gatewayResponse.FinishReason, recorder.Body.String())
}
if rawResponse == "" {
t.Fatalf("message=%q raw response is empty", message)
}
if message == "ты кто" {
if semantic.Interpretation.SpeechAct != interaction.SpeechActQuestion || !semantic.NeedsCognition {
t.Fatalf("semantic path still fails punctuation-free identity question: %+v", semantic.Interpretation)
}
if gatewayResponse.Candidate.PrimarySpeechAct != "QUESTION" {
t.Fatalf("gateway did not preserve question semantics: %+v", gatewayResponse.Candidate)
}
}
t.Logf("TRACE message=%q deterministic=%s/%s needs_cognition=%t raw=%q gateway_candidate=%+v", message, semantic.Interpretation.SpeechAct, semantic.Interpretation.Applicability, semantic.NeedsCognition, truncate(rawResponse, 180), gatewayResponse.Candidate)
}
}
type traceResolver struct {
selected capability.ResolvedCognitiveBinding
}
func (r traceResolver) Resolve(context.Context, capability.CognitiveRequirement) (capability.ResolvedCognitiveBinding, error) {
return r.selected, nil
}
func (r traceResolver) Observe(context.Context, capability.CognitiveUsageObservation) error {
return nil
}
func (r traceResolver) RegisterDiscovery(context.Context, capability.CognitiveDiscoverySnapshot) (capability.CognitiveDiscoveryRegistration, error) {
return capability.CognitiveDiscoveryRegistration{}, nil
}
func firstRawModel(ctx context.Context, base string) (string, error) {
request, err := http.NewRequestWithContext(ctx, http.MethodGet, base+"/models", nil)
if err != nil {
return "", err
}
response, err := http.DefaultClient.Do(request)
if err != nil {
return "", err
}
defer response.Body.Close()
var payload struct {
Data []struct {
ID string `json:"id"`
} `json:"data"`
}
if err := json.NewDecoder(io.LimitReader(response.Body, 64<<10)).Decode(&payload); err != nil {
return "", err
}
if len(payload.Data) == 0 || payload.Data[0].ID == "" {
return "", io.EOF
}
return payload.Data[0].ID, nil
}
func rawCompletion(ctx context.Context, base, model, message string) (string, error) {
payload, err := json.Marshal(map[string]any{
"model": model,
"max_tokens": 128,
"messages": []map[string]string{
{"role": "user", "content": message},
},
"stream": false,
})
if err != nil {
return "", err
}
request, err := http.NewRequestWithContext(ctx, http.MethodPost, base+"/chat/completions", bytes.NewReader(payload))
if err != nil {
return "", err
}
request.Header.Set("Content-Type", "application/json")
response, err := http.DefaultClient.Do(request)
if err != nil {
return "", err
}
defer response.Body.Close()
var result struct {
Choices []struct {
Message struct {
Content string `json:"content"`
} `json:"message"`
} `json:"choices"`
}
if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&result); err != nil {
return "", err
}
if len(result.Choices) == 0 {
return "", io.EOF
}
return result.Choices[0].Message.Content, nil
}
func truncate(value string, max int) string {
if len(value) <= max {
return value
}
return value[:max] + "..."
}
+1
View File
@@ -63,6 +63,7 @@ func main() {
mux.HandleFunc("POST /v1/proposals/deterministic", deterministicProposal)
mux.HandleFunc("POST /v1/advisory-policy", gateway.policyHandler)
mux.HandleFunc("POST /v1/advisories", gateway.advisoryHandler)
mux.HandleFunc("POST /v1/interpretations", gateway.interpretationHandler)
discovery := discoveryService{resolver: resolver, providers: discoveries, owner: identity.PrincipalID(envOr("COGNITIVE_OWNER_PRINCIPAL_ID", "domovoy-creator-principal")), now: time.Now}
mux.HandleFunc("POST /v1/provider-discovery/{provider}", discovery.handler)
log.Printf("cognitive-worker listening on %s", addr)
@@ -0,0 +1,125 @@
package main
import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"net/url"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/contracts/cognitive"
"git.cin.su/m/Assistant/contracts/identity"
"git.cin.su/m/Assistant/contracts/interaction"
interactiondomain "git.cin.su/m/Assistant/modules/interaction/domain"
"git.cin.su/m/Assistant/platform/ids"
)
type cognitiveInterpretationClient struct {
baseURL *url.URL
client *http.Client
}
func newCognitiveInterpretationClient(rawURL string, client *http.Client) (cognitiveInterpretationClient, error) {
base, err := url.Parse(rawURL)
if err != nil || base.Scheme == "" || base.Host == "" {
return cognitiveInterpretationClient{}, fmt.Errorf("invalid Cognitive Runtime URL")
}
if client == nil {
client = http.DefaultClient
}
return cognitiveInterpretationClient{baseURL: base, client: client}, nil
}
func (c cognitiveInterpretationClient) Interpret(ctx context.Context, request cognitive.GatewayInterpretationRequest) (cognitive.GatewayInterpretationResponse, error) {
target := *c.baseURL
target.Path = "/v1/interpretations"
payload, err := json.Marshal(request)
if err != nil {
return cognitive.GatewayInterpretationResponse{}, err
}
upstream, err := http.NewRequestWithContext(ctx, http.MethodPost, target.String(), bytes.NewReader(payload))
if err != nil {
return cognitive.GatewayInterpretationResponse{}, err
}
upstream.Header.Set("Content-Type", "application/json")
response, err := c.client.Do(upstream)
if err != nil {
return cognitive.GatewayInterpretationResponse{}, err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return cognitive.GatewayInterpretationResponse{}, fmt.Errorf("cognitive interpretation status %d", response.StatusCode)
}
var result cognitive.GatewayInterpretationResponse
if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
return cognitive.GatewayInterpretationResponse{}, err
}
return result, nil
}
func shouldRequestBroaderInterpretation(result interactiondomain.SemanticResult) bool {
switch result.Interpretation.Applicability {
case interaction.SemanticNeedsBroaderInterpret, interaction.SemanticLowConfidence, interaction.SemanticMixedIntent:
return true
default:
return false
}
}
func buildGatewayInterpretationRequest(session identity.CreatorSession, utterance interaction.HumanUtterance, semantic interactiondomain.SemanticResult, projectNames []string) cognitive.GatewayInterpretationRequest {
requestID, _ := ids.New()
return cognitive.GatewayInterpretationRequest{
Version: cognitive.CreatorAdvisoryV1,
RequestID: cognitive.RequestID(requestID),
ActorID: session.ActorID,
PrincipalID: session.PrincipalID,
ScopeID: authority.ScopeID("domovoy-global-scope"),
Message: utterance.Content,
Locale: "ru",
MaxOutputBytes: 4096,
DataPolicy: capability.DataPolicyLocalOnly,
DeterministicSpeechAct: string(semantic.Interpretation.SpeechAct),
DeterministicSecondary: string(semantic.Interpretation.SecondarySpeechAct),
DeterministicConfidence: semantic.Interpretation.ConfidenceMillis,
DeterministicApplicability: cognitive.InterpretationApplicability(semantic.Interpretation.Applicability),
RequestedOutcome: semantic.Interpretation.RequestedOutcome,
ProjectNames: projectNames,
}
}
func interactionCandidateFromGateway(utteranceID interaction.HumanUtteranceID, candidate cognitive.GatewayInterpretationCandidate, now interface{ UnixMilli() int64 }) (interaction.SemanticCandidate, error) {
id, err := ids.New()
if err != nil {
return interaction.SemanticCandidate{}, err
}
return interaction.SemanticCandidate{
ID: interaction.SemanticCandidateID(id),
UtteranceID: utteranceID,
Source: interaction.CandidateSourceCognitive,
SelectionState: interaction.CandidateSelected,
PrimarySpeechAct: interaction.SpeechAct(candidate.PrimarySpeechAct),
SecondarySpeechAct: interaction.SpeechAct(candidate.SecondarySpeechAct),
ConfidenceMillis: candidate.ConfidenceMillis,
Applicability: interaction.SemanticApplicability(candidate.Applicability),
RequestedOutcome: candidate.RequestedOutcome,
Clarification: interaction.ClarificationState(candidate.Clarification),
NeedsCognition: candidate.NeedsCognition,
SelectionReason: candidate.SelectionReason,
CapabilityHints: capabilityHintStrings(candidate.CapabilityHints),
RecordedAtUnixMillis: now.UnixMilli(),
}, nil
}
func capabilityHintStrings(values []capability.CapabilityKind) []string {
result := make([]string, 0, len(values))
for _, value := range values {
if value == "" {
continue
}
result = append(result, string(value))
}
return result
}
+35 -1
View File
@@ -8,6 +8,7 @@ import (
"git.cin.su/m/Assistant/adapters/postgres"
"git.cin.su/m/Assistant/contracts/authority"
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/contracts/cognitive"
"git.cin.su/m/Assistant/contracts/continuity"
"git.cin.su/m/Assistant/contracts/epistemics"
"git.cin.su/m/Assistant/contracts/identity"
@@ -111,6 +112,10 @@ func main() {
if err != nil {
log.Fatal(err)
}
cognitiveClient, err := newCognitiveInterpretationClient(envOr("COGNITIVE_RUNTIME_URL", "http://cognitive-worker:8083"), &http.Client{Timeout: 20 * 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) {
@@ -288,11 +293,24 @@ func main() {
http.Error(w, "interpret chat message", http.StatusServiceUnavailable)
return
}
if shouldRequestBroaderInterpretation(semantic) {
projectNames := make([]string, 0, len(semantic.Projects))
for _, ref := range semantic.Projects {
if ref.ProjectDisplayName != "" {
projectNames = append(projectNames, ref.ProjectDisplayName)
}
}
if response, interpretationErr := cognitiveClient.Interpret(r.Context(), buildGatewayInterpretationRequest(session, utterance, semantic, projectNames)); interpretationErr == nil && response.FinishReason == cognitive.FinishCompleted {
if candidate, candidateErr := interactionCandidateFromGateway(utterance.ID, response.Candidate, now); candidateErr == nil {
semantic = interactiondomain.ApplyCognitiveCandidate(semantic, utterance.Content, candidate, previousFocus)
}
}
}
if err := interactionRepository.AppendUtterance(r.Context(), conversation, utterance, intent, relations); err != nil {
http.Error(w, "save chat message", http.StatusInternalServerError)
return
}
if err := interactionRepository.SaveSemanticResult(r.Context(), semantic.Interpretation, semantic.Projects, semantic.Relations); err != nil {
if err := interactionRepository.SaveSemanticResult(r.Context(), semantic.Interpretation, semantic.Candidates, semantic.Projects, semantic.Relations); err != nil {
http.Error(w, "save chat semantics", http.StatusInternalServerError)
return
}
@@ -349,7 +367,11 @@ func main() {
ProjectProvenance: work.ProjectProvenanceRef(activeFocusProvenance),
Message: utterance.Content,
SpeechAct: work.SpeechActRef(semantic.Interpretation.SpeechAct),
SecondarySpeechAct: work.SpeechActRef(semantic.Interpretation.SecondarySpeechAct),
AssertionVerification: epistemics.VerificationState(semantic.Interpretation.AssertionVerification),
CapabilityHints: toCapabilityKinds(semantic.CapabilityHints),
NeedsCognition: semantic.NeedsCognition,
RequiresClarification: semantic.Interpretation.Clarification == interaction.ClarificationRequired,
ReceivedAtUnixMillis: utterance.ReceivedAtUnixMillis,
}
helpPath := workdomain.DetermineHelpPath(planningInput)
@@ -1087,6 +1109,18 @@ func humanCapabilityList(kinds []capability.CapabilityKind) string {
return strings.Join(labels, ", ")
}
func toCapabilityKinds(values []string) []capability.CapabilityKind {
result := make([]capability.CapabilityKind, 0, len(values))
for _, value := range values {
kind := capability.CapabilityKind(strings.TrimSpace(value))
if kind == "" {
continue
}
result = append(result, kind)
}
return result
}
func delegationAttentionRef(id work.DelegationID) string {
return "work:delegation:" + string(id)
}