363 lines
12 KiB
Go
363 lines
12 KiB
Go
package acp
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
"xworkmate-bridge/internal/desktop"
|
|
"xworkmate-bridge/internal/shared"
|
|
|
|
"github.com/pion/webrtc/v4"
|
|
)
|
|
|
|
func (s *Server) handleRequest(request shared.RPCRequest, notify func(map[string]any)) (map[string]any, *shared.RPCError) {
|
|
method := strings.TrimSpace(request.Method)
|
|
ctx := context.Background()
|
|
|
|
switch method {
|
|
case "health":
|
|
return map[string]any{"status": "ok", "version": "0.7.0", "role": "acp-control-plane"}, nil
|
|
|
|
case "acp.capabilities":
|
|
return s.catalog.Get(), nil
|
|
|
|
case "session.start", "session.message":
|
|
return s.orchestrator.Process(ctx, method, request.Params, notify)
|
|
|
|
case "session.cancel":
|
|
sessionID := shared.StringArg(request.Params, "sessionId", "")
|
|
s.cancelSession(ctx, sessionID)
|
|
return map[string]any{"accepted": true}, nil
|
|
|
|
case "session.close":
|
|
sessionID := shared.StringArg(request.Params, "sessionId", "")
|
|
closed := s.closeSession(ctx, sessionID)
|
|
return map[string]any{"accepted": true, "closed": closed}, nil
|
|
|
|
case "xworkmate.routing.resolve":
|
|
res, err := s.routingEngine.Resolve(ctx, request.Params)
|
|
if err != nil {
|
|
return nil, &shared.RPCError{Code: -32602, Message: err.Error()}
|
|
}
|
|
return map[string]any{
|
|
"resolvedExecutionTarget": res.TargetID,
|
|
"resolvedProviderId": res.ProviderID,
|
|
"resolvedGatewayProviderId": res.GatewayProviderID,
|
|
"resolvedModel": res.Model,
|
|
"resolvedSkills": res.Skills,
|
|
"status": res.Status,
|
|
"unavailable": res.Status == "unavailable",
|
|
"unavailableCode": res.UnavailableCode,
|
|
"unavailableMessage": res.UnavailableMsg,
|
|
"skillResolutionSource": res.SkillResolutionSource,
|
|
"needsSkillInstall": res.NeedsSkillInstall,
|
|
"skillInstallRequestId": res.SkillInstallRequestID,
|
|
}, nil
|
|
|
|
case "xworkmate.gateway.connect", "xworkmate.gateway.request", "xworkmate.gateway.disconnect":
|
|
// Gateway 语义由专门的 Gateway 组件通过 Adapter 处理
|
|
return s.handleGatewayMethod(ctx, method, request.Params, notify)
|
|
|
|
case "xworkmate.desktop.offer", "xworkmate.desktop.ice", "xworkmate.desktop.close":
|
|
return s.handleDesktopMethod(ctx, method, request.Params, notify)
|
|
|
|
case "xworkmate.jobs.submit", "xworkmate.jobs.get", "xworkmate.jobs.list", "xworkmate.jobs.stats":
|
|
return s.handleJobMethod(ctx, method, request.Params, notify)
|
|
|
|
case "xworkmate.tasks.get":
|
|
return s.handleTaskGet(ctx, request.Params, notify), nil
|
|
|
|
case "xworkmate.tasks.cancel":
|
|
return s.handleTaskCancel(ctx, request.Params, notify), nil
|
|
|
|
case "xworkmate.tools.invoke":
|
|
return s.invokeOpenClawTool(ctx, request.Params)
|
|
|
|
default:
|
|
return nil, &shared.RPCError{
|
|
Code: -32601,
|
|
Message: fmt.Sprintf("unknown method: %s", method),
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *Server) handleTaskGet(ctx context.Context, params map[string]any, notify func(map[string]any)) map[string]any {
|
|
sess := s.findTaskSession(params)
|
|
if sess == nil {
|
|
sess = s.reassociateOpenClawTask(params)
|
|
}
|
|
if sess == nil {
|
|
return map[string]any{"status": "not_found"}
|
|
}
|
|
return s.orchestrator.probeOpenClawTask(ctx, sess, notify)
|
|
}
|
|
|
|
func (s *Server) handleTaskCancel(ctx context.Context, params map[string]any, notify func(map[string]any)) map[string]any {
|
|
sess := s.findTaskSession(params)
|
|
if sess == nil {
|
|
sess = s.reassociateOpenClawTask(params)
|
|
}
|
|
if sess == nil {
|
|
return map[string]any{"accepted": false, "status": "not_found"}
|
|
}
|
|
sess.mu.Lock()
|
|
gatewayProvider := sess.task.GatewayProviderID
|
|
runID := sess.task.RunID
|
|
sess.task.State = TaskStateCancelled
|
|
sess.task.UpdatedAt = time.Now()
|
|
sess.task.ProgressStage = "cancelled"
|
|
sess.task.ProgressMessage = "OpenClaw task cancelled"
|
|
sess.task.ProgressTerminal = true
|
|
if sess.openClaw != nil {
|
|
sess.openClaw.ProgressStage = "cancelled"
|
|
sess.openClaw.ProgressMessage = "OpenClaw task cancelled"
|
|
sess.openClaw.ProgressTerminal = true
|
|
}
|
|
snapshot := openClawSessionSnapshotLocked(sess)
|
|
sess.mu.Unlock()
|
|
s.orchestrator.releaseOpenClawAdmission(sess)
|
|
if strings.TrimSpace(gatewayProvider) != "" && strings.TrimSpace(runID) != "" && s.gateway != nil {
|
|
_ = s.gateway.RequestByMode(
|
|
gatewayProvider,
|
|
"agent.cancel",
|
|
map[string]any{"runId": runID},
|
|
5*time.Second,
|
|
notify,
|
|
)
|
|
}
|
|
snapshot["accepted"] = true
|
|
return snapshot
|
|
}
|
|
|
|
func (s *Server) findTaskSession(params map[string]any) *session {
|
|
sessionID := strings.TrimSpace(shared.StringArg(params, "sessionId", ""))
|
|
threadID := strings.TrimSpace(shared.StringArg(params, "threadId", ""))
|
|
turnID := strings.TrimSpace(shared.StringArg(params, "turnId", ""))
|
|
runID := strings.TrimSpace(shared.StringArg(params, "runId", ""))
|
|
artifactScope := strings.TrimSpace(shared.StringArg(params, "artifactScope", ""))
|
|
s.mu.RLock()
|
|
defer s.mu.RUnlock()
|
|
if sessionID != "" && s.sessions[sessionID] != nil {
|
|
return s.sessions[sessionID]
|
|
}
|
|
for _, candidate := range s.sessions {
|
|
if candidate == nil {
|
|
continue
|
|
}
|
|
candidate.mu.Lock()
|
|
matches := (threadID != "" && candidate.threadID == threadID) ||
|
|
(turnID != "" && candidate.task.TurnID == turnID) ||
|
|
(runID != "" && candidate.task.RunID == runID) ||
|
|
(artifactScope != "" && candidate.task.ArtifactScope == artifactScope)
|
|
candidate.mu.Unlock()
|
|
if matches {
|
|
return candidate
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Server) reassociateOpenClawTask(params map[string]any) *session {
|
|
runID := strings.TrimSpace(shared.StringArg(params, "runId", ""))
|
|
artifactScope := strings.TrimSpace(shared.StringArg(params, "artifactScope", ""))
|
|
if runID == "" || artifactScope == "" {
|
|
return nil
|
|
}
|
|
sessionID := strings.TrimSpace(shared.StringArg(params, "sessionId", ""))
|
|
threadID := strings.TrimSpace(shared.StringArg(params, "threadId", sessionID))
|
|
if sessionID == "" {
|
|
sessionID = threadID
|
|
}
|
|
if sessionID == "" {
|
|
sessionID = strings.TrimSpace(shared.StringArg(params, "sessionKey", ""))
|
|
}
|
|
if sessionID == "" {
|
|
sessionID = "openclaw:" + runID
|
|
}
|
|
if threadID == "" {
|
|
threadID = sessionID
|
|
}
|
|
turnID := strings.TrimSpace(shared.StringArg(params, "turnId", runID))
|
|
sessionKey := strings.TrimSpace(shared.StringArg(params, "sessionKey", threadID))
|
|
gatewayProvider := strings.TrimSpace(shared.StringArg(params, "gatewayProviderId", "openclaw"))
|
|
now := time.Now()
|
|
prepared := &openClawPreparedArtifactScope{
|
|
ArtifactScope: artifactScope,
|
|
ArtifactDirectory: strings.TrimSpace(shared.StringArg(params, "artifactDirectory", "")),
|
|
RelativeArtifactDirectory: artifactScope,
|
|
ScopeKind: "task",
|
|
RemoteWorkingDirectory: strings.TrimSpace(shared.StringArg(params, "remoteWorkingDirectory", "")),
|
|
RemoteWorkspaceRefKind: strings.TrimSpace(shared.StringArg(params, "remoteWorkspaceRefKind", "")),
|
|
}
|
|
contract := openClawArtifactContract{
|
|
TaskLoadClass: strings.TrimSpace(shared.StringArg(params, "taskLoadClass", "")),
|
|
ExpectedArtifactExtensions: normalizeOpenClawExtensionList(shared.ListArg(params, "expectedArtifactExtensions")),
|
|
RequiredFinalExtensions: normalizeOpenClawExtensionList(shared.ListArg(params, "requiredArtifactExtensions")),
|
|
}
|
|
taskLoadClass, budget := openClawTaskRuntimePolicy(params, map[string]any{"sessionKey": sessionKey}, contract)
|
|
if explicitBudget := shared.IntArg(shared.StringArg(params, "runtimeBudgetMinutes", ""), 0); explicitBudget > 0 {
|
|
budget = explicitBudget
|
|
}
|
|
sess := s.getOrCreateSession(sessionID, threadID)
|
|
sess.mu.Lock()
|
|
sess.provider = gatewayProvider
|
|
sess.target = "gateway"
|
|
sess.mode = "gateway"
|
|
sess.task = QueuedTask{
|
|
SessionID: sessionID,
|
|
ThreadID: threadID,
|
|
TurnID: turnID,
|
|
RunID: runID,
|
|
SessionKey: sessionKey,
|
|
Provider: gatewayProvider,
|
|
Target: "gateway",
|
|
GatewayProviderID: gatewayProvider,
|
|
State: TaskStateRunning,
|
|
Kind: TaskKindGateway,
|
|
TaskLoadClass: taskLoadClass,
|
|
ArtifactScope: artifactScope,
|
|
ArtifactDirectory: prepared.ArtifactDirectory,
|
|
RuntimeBudgetMinutes: budget,
|
|
StartedAt: now,
|
|
DeadlineAt: now.Add(time.Duration(budget) * time.Minute),
|
|
UpdatedAt: now,
|
|
ProgressStage: "reassociated",
|
|
ProgressMessage: "OpenClaw task reassociated from task handle",
|
|
}
|
|
sess.openClaw = &OpenClawTaskRecord{
|
|
SessionID: sessionID,
|
|
ThreadID: threadID,
|
|
TurnID: turnID,
|
|
RunID: runID,
|
|
SessionKey: sessionKey,
|
|
GatewayProviderID: gatewayProvider,
|
|
TaskLoadClass: taskLoadClass,
|
|
ArtifactSinceUnixMs: 0,
|
|
RuntimeBudgetMinutes: budget,
|
|
StartedAt: now,
|
|
DeadlineAt: now.Add(time.Duration(budget) * time.Minute),
|
|
ProgressStage: "reassociated",
|
|
ProgressMessage: "OpenClaw task reassociated from task handle",
|
|
ChatParams: map[string]any{"sessionKey": sessionKey},
|
|
PreparedArtifact: prepared,
|
|
ArtifactContract: contract,
|
|
}
|
|
sess.lastResult = openClawRunningTaskResult(sess.openClaw)
|
|
sess.mu.Unlock()
|
|
return sess
|
|
}
|
|
|
|
func (s *Server) cancelSession(ctx context.Context, sessionID string) {
|
|
s.mu.RLock()
|
|
sess, ok := s.sessions[sessionID]
|
|
s.mu.RUnlock()
|
|
if ok && sess != nil && sess.compat != nil {
|
|
sess.mu.Lock()
|
|
sess.task.State = TaskStateCancelled
|
|
sess.task.UpdatedAt = time.Now()
|
|
sess.mu.Unlock()
|
|
_ = sess.compat.CancelSession(ctx, sessionID)
|
|
}
|
|
}
|
|
|
|
func (s *Server) closeSession(ctx context.Context, sessionID string) bool {
|
|
s.mu.Lock()
|
|
_, existed := s.sessions[sessionID]
|
|
if existed {
|
|
delete(s.sessions, sessionID)
|
|
}
|
|
s.mu.Unlock()
|
|
return existed
|
|
}
|
|
|
|
func (s *Server) handleDesktopMethod(ctx context.Context, method string, params map[string]any, notify func(map[string]any)) (map[string]any, *shared.RPCError) {
|
|
sessionID := strings.TrimSpace(shared.StringArg(params, "sessionId", ""))
|
|
if sessionID == "" {
|
|
sessionID = "default"
|
|
}
|
|
|
|
srv := desktop.GetService()
|
|
|
|
switch method {
|
|
case "xworkmate.desktop.offer":
|
|
sdpOffer := strings.TrimSpace(shared.StringArg(params, "sdpOffer", ""))
|
|
if sdpOffer == "" {
|
|
return nil, &shared.RPCError{Code: -32602, Message: "sdpOffer is required"}
|
|
}
|
|
|
|
display := strings.TrimSpace(shared.StringArg(params, "display", ""))
|
|
width := shared.IntArg(shared.StringArg(params, "width", ""), 1280)
|
|
height := shared.IntArg(shared.StringArg(params, "height", ""), 720)
|
|
fps := shared.IntArg(shared.StringArg(params, "fps", ""), 30)
|
|
bitrate := shared.IntArg(shared.StringArg(params, "bitrate", ""), 2000)
|
|
useGPU := shared.BoolArg(shared.StringArg(params, "useGpu", ""), false)
|
|
|
|
var iceServers []string
|
|
if rawIce, ok := params["iceServers"].([]any); ok {
|
|
for _, ice := range rawIce {
|
|
if s, ok := ice.(string); ok {
|
|
iceServers = append(iceServers, s)
|
|
}
|
|
}
|
|
}
|
|
|
|
cfg := desktop.PipelineConfig{
|
|
Display: display,
|
|
Port: 5004,
|
|
Width: width,
|
|
Height: height,
|
|
FPS: fps,
|
|
Bitrate: bitrate,
|
|
UseGPU: useGPU,
|
|
ToolType: "auto",
|
|
}
|
|
|
|
sess, err := srv.StartSession(sessionID, cfg, iceServers)
|
|
if err != nil {
|
|
return nil, &shared.RPCError{Code: -32001, Message: fmt.Sprintf("failed to start desktop session: %v", err)}
|
|
}
|
|
|
|
sdpAnswer, err := sess.WebRTC.ProcessOffer(sdpOffer)
|
|
if err != nil {
|
|
srv.StopSession(sessionID)
|
|
return nil, &shared.RPCError{Code: -32002, Message: fmt.Sprintf("failed to process SDP offer: %v", err)}
|
|
}
|
|
|
|
return map[string]any{
|
|
"sessionId": sessionID,
|
|
"sdpAnswer": sdpAnswer,
|
|
}, nil
|
|
|
|
case "xworkmate.desktop.ice":
|
|
candidateData, ok := params["candidate"].(map[string]any)
|
|
if !ok {
|
|
return nil, &shared.RPCError{Code: -32602, Message: "candidate object is required"}
|
|
}
|
|
|
|
var candidate webrtc.ICECandidateInit
|
|
bytes, err := json.Marshal(candidateData)
|
|
if err != nil {
|
|
return nil, &shared.RPCError{Code: -32602, Message: fmt.Sprintf("failed to marshal candidate: %v", err)}
|
|
}
|
|
if err := json.Unmarshal(bytes, &candidate); err != nil {
|
|
return nil, &shared.RPCError{Code: -32602, Message: fmt.Sprintf("failed to unmarshal candidate: %v", err)}
|
|
}
|
|
|
|
if err := srv.AddICECandidate(sessionID, candidate); err != nil {
|
|
return nil, &shared.RPCError{Code: -32003, Message: fmt.Sprintf("failed to add ICE candidate: %v", err)}
|
|
}
|
|
|
|
return map[string]any{"status": "ok"}, nil
|
|
|
|
case "xworkmate.desktop.close":
|
|
srv.StopSession(sessionID)
|
|
return map[string]any{"status": "closed"}, nil
|
|
|
|
default:
|
|
return nil, &shared.RPCError{Code: -32601, Message: fmt.Sprintf("unknown desktop method: %s", method)}
|
|
}
|
|
}
|
|
|