修雨
1c90edb92a
The codex app-server read loop reports EOF before closing the message channel, so when the process exits right after its final frame, both channels are ready and select picks one at random — runTurn could drop an already-received turn/completed and fail with "stream ended before turn/completed: EOF" (the CI flake on this PR and #8). Drain buffered frames first; reproduced at ~7%/300 runs before, 0/300 after.
558 lines
14 KiB
Go
558 lines
14 KiB
Go
// Copyright 2026 Alibaba Group
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package helpers
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
const codexRobotDeveloperInstructions = "你是钉钉群聊里的智能助手，请用简洁、自然的中文直接回答用户问题；不要提及系统提示、内部协议或运行时细节；不要主动读写文件或执行命令。"
|
|
|
|
// codexAppServerForwarder uses Codex's official app-server JSON-RPC protocol to
|
|
// keep one Codex thread per DingTalk conversation. It still has an exec fallback
|
|
// so an experimental app-server regression does not make the robot unusable.
|
|
type codexAppServerForwarder struct {
|
|
bin string
|
|
env []string
|
|
timeout time.Duration
|
|
workDir string
|
|
model string
|
|
sessions *codexThreadSessions
|
|
fallback *execForwarder
|
|
}
|
|
|
|
func newCodexAppServerForwarder(bin string, env []string, timeout time.Duration, opts connectAgentOptions, fallback *execForwarder) forwarder {
|
|
var sessions *codexThreadSessions
|
|
if opts.Memory {
|
|
sessions = newCodexThreadSessions()
|
|
}
|
|
return &codexAppServerForwarder{
|
|
bin: bin,
|
|
env: env,
|
|
timeout: timeout,
|
|
workDir: opts.WorkDir,
|
|
model: opts.Model,
|
|
sessions: sessions,
|
|
fallback: fallback,
|
|
}
|
|
}
|
|
|
|
func codexAppServerEnabled() bool {
|
|
return strings.TrimSpace(os.Getenv("DWS_CODEX_APP_SERVER")) != "0"
|
|
}
|
|
|
|
func codexAppServerPlanEnabled() bool {
|
|
return codexAppServerEnabled() && strings.TrimSpace(os.Getenv("DWS_AGENT_CMD")) == ""
|
|
}
|
|
|
|
func (f *codexAppServerForwarder) canStream() bool { return true }
|
|
|
|
func (f *codexAppServerForwarder) label() string {
|
|
memo := "stateless"
|
|
if f.sessions != nil {
|
|
memo = "thread-memory"
|
|
}
|
|
return fmt.Sprintf("codex-app-server:%s (%s, exec-fallback)", f.bin, memo)
|
|
}
|
|
|
|
func (f *codexAppServerForwarder) forward(ctx context.Context, convID, text string) (string, error) {
|
|
return f.forwardStream(ctx, convID, text, nil)
|
|
}
|
|
|
|
func (f *codexAppServerForwarder) forwardStream(ctx context.Context, convID, text string, onDelta func(string)) (string, error) {
|
|
reply, err := f.forwardAppServer(ctx, convID, text, onDelta)
|
|
if err == nil {
|
|
return reply, nil
|
|
}
|
|
fmt.Fprintf(os.Stderr, "[connect][codex] app-server 调用失败，降级 codex exec: %v\n", err)
|
|
if f.fallback == nil {
|
|
return "", err
|
|
}
|
|
fallbackReply, fallbackErr := f.fallback.forward(ctx, convID, text)
|
|
if fallbackErr != nil {
|
|
return "", fmt.Errorf("codex app-server failed: %v; codex exec fallback failed: %w", err, fallbackErr)
|
|
}
|
|
return fallbackReply, nil
|
|
}
|
|
|
|
func (f *codexAppServerForwarder) forwardAppServer(ctx context.Context, convID, text string, onDelta func(string)) (string, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, f.timeout)
|
|
defer cancel()
|
|
|
|
var state *codexThreadState
|
|
if f.sessions != nil {
|
|
state = f.sessions.state(convID)
|
|
state.mu.Lock()
|
|
defer state.mu.Unlock()
|
|
}
|
|
|
|
cli, err := newCodexAppServerClient(ctx, f.bin, f.env, f.cwd())
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer cli.close()
|
|
|
|
if err := cli.initialize(ctx); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
threadID := ""
|
|
if state != nil {
|
|
threadID = state.threadID
|
|
}
|
|
if threadID != "" {
|
|
resumed, err := cli.resumeThread(ctx, f.threadParams(threadID))
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "[connect][codex] resume thread %s 失败，重建会话: %v\n", threadID, err)
|
|
threadID = ""
|
|
state.threadID = ""
|
|
} else {
|
|
threadID = resumed
|
|
}
|
|
}
|
|
if threadID == "" {
|
|
started, err := cli.startThread(ctx, f.threadParams(""))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
threadID = started
|
|
if state != nil {
|
|
state.threadID = threadID
|
|
}
|
|
}
|
|
|
|
reply, err := cli.runTurn(ctx, threadID, text, onDelta)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return reply, nil
|
|
}
|
|
|
|
func (f *codexAppServerForwarder) cwd() string {
|
|
if f.workDir == "" {
|
|
return connectWorkDir()
|
|
}
|
|
if abs, err := filepath.Abs(f.workDir); err == nil {
|
|
return abs
|
|
}
|
|
return f.workDir
|
|
}
|
|
|
|
func (f *codexAppServerForwarder) threadParams(threadID string) map[string]any {
|
|
params := map[string]any{
|
|
"approvalPolicy": "never",
|
|
"cwd": f.cwd(),
|
|
"developerInstructions": codexRobotDeveloperInstructions,
|
|
"sandbox": "read-only",
|
|
}
|
|
if f.model != "" {
|
|
params["model"] = f.model
|
|
}
|
|
if threadID != "" {
|
|
params["threadId"] = threadID
|
|
}
|
|
return params
|
|
}
|
|
|
|
type codexThreadSessions struct {
|
|
mu sync.Mutex
|
|
m map[string]*codexThreadState
|
|
}
|
|
|
|
type codexThreadState struct {
|
|
mu sync.Mutex
|
|
threadID string
|
|
}
|
|
|
|
func newCodexThreadSessions() *codexThreadSessions {
|
|
return &codexThreadSessions{m: make(map[string]*codexThreadState)}
|
|
}
|
|
|
|
func (s *codexThreadSessions) state(convID string) *codexThreadState {
|
|
key := strings.TrimSpace(convID)
|
|
if key == "" {
|
|
key = "_default"
|
|
}
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
if st, ok := s.m[key]; ok {
|
|
return st
|
|
}
|
|
st := &codexThreadState{}
|
|
s.m[key] = st
|
|
return st
|
|
}
|
|
|
|
type codexAppServerClient struct {
|
|
cmd *exec.Cmd
|
|
stdin io.WriteCloser
|
|
msgs chan codexRPCMessage
|
|
readErr chan error
|
|
done chan struct{}
|
|
closeOnce sync.Once
|
|
stderr *lockedBuffer
|
|
nextID int
|
|
}
|
|
|
|
type lockedBuffer struct {
|
|
mu sync.Mutex
|
|
buf bytes.Buffer
|
|
}
|
|
|
|
func (b *lockedBuffer) Write(p []byte) (int, error) {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
return b.buf.Write(p)
|
|
}
|
|
|
|
func (b *lockedBuffer) String() string {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
return b.buf.String()
|
|
}
|
|
|
|
type codexRPCMessage struct {
|
|
ID *int `json:"id,omitempty"`
|
|
Method string `json:"method,omitempty"`
|
|
Params json.RawMessage `json:"params,omitempty"`
|
|
Result json.RawMessage `json:"result,omitempty"`
|
|
Error *codexRPCError `json:"error,omitempty"`
|
|
}
|
|
|
|
type codexRPCError struct {
|
|
Code int `json:"code"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
func newCodexAppServerClient(ctx context.Context, bin string, env []string, cwd string) (*codexAppServerClient, error) {
|
|
cmd := exec.CommandContext(ctx, bin, "app-server", "--stdio")
|
|
cmd.Dir = cwd
|
|
if len(env) > 0 {
|
|
cmd.Env = append(os.Environ(), env...)
|
|
}
|
|
stdin, err := cmd.StdinPipe()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stdout, err := cmd.StdoutPipe()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
stderr := &lockedBuffer{}
|
|
cmd.Stderr = stderr
|
|
if err := cmd.Start(); err != nil {
|
|
return nil, err
|
|
}
|
|
cli := &codexAppServerClient{
|
|
cmd: cmd,
|
|
stdin: stdin,
|
|
msgs: make(chan codexRPCMessage, 64),
|
|
readErr: make(chan error, 1),
|
|
done: make(chan struct{}),
|
|
stderr: stderr,
|
|
nextID: 1,
|
|
}
|
|
go cli.readLoop(stdout)
|
|
return cli, nil
|
|
}
|
|
|
|
func (c *codexAppServerClient) readLoop(stdout io.Reader) {
|
|
scanner := bufio.NewScanner(stdout)
|
|
scanner.Buffer(make([]byte, 0, 64*1024), 4*1024*1024)
|
|
for scanner.Scan() {
|
|
line := strings.TrimSpace(scanner.Text())
|
|
if line == "" {
|
|
continue
|
|
}
|
|
var msg codexRPCMessage
|
|
if err := json.Unmarshal([]byte(line), &msg); err != nil {
|
|
c.reportReadErr(fmt.Errorf("parse app-server JSONL: %w", err))
|
|
close(c.msgs)
|
|
return
|
|
}
|
|
select {
|
|
case c.msgs <- msg:
|
|
case <-c.done:
|
|
return
|
|
}
|
|
}
|
|
if err := scanner.Err(); err != nil {
|
|
c.reportReadErr(err)
|
|
} else {
|
|
c.reportReadErr(io.EOF)
|
|
}
|
|
close(c.msgs)
|
|
}
|
|
|
|
func (c *codexAppServerClient) close() {
|
|
c.closeOnce.Do(func() {
|
|
close(c.done)
|
|
_ = c.stdin.Close()
|
|
if c.cmd.Process != nil {
|
|
_ = c.cmd.Process.Kill()
|
|
}
|
|
_ = c.cmd.Wait()
|
|
})
|
|
}
|
|
|
|
func (c *codexAppServerClient) reportReadErr(err error) {
|
|
select {
|
|
case c.readErr <- err:
|
|
case <-c.done:
|
|
}
|
|
}
|
|
|
|
func (c *codexAppServerClient) initialize(ctx context.Context) error {
|
|
id := c.requestID()
|
|
if err := c.send(map[string]any{
|
|
"id": id,
|
|
"method": "initialize",
|
|
"params": map[string]any{
|
|
"capabilities": map[string]any{"experimentalApi": true},
|
|
"clientInfo": map[string]any{
|
|
"name": "dws-devapp-robot-connect",
|
|
"title": "DWS DevApp Robot Connect",
|
|
"version": "0.1.0",
|
|
},
|
|
},
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
if _, err := c.waitResponse(ctx, id); err != nil {
|
|
return err
|
|
}
|
|
return c.send(map[string]any{"method": "initialized", "params": map[string]any{}})
|
|
}
|
|
|
|
func (c *codexAppServerClient) startThread(ctx context.Context, params map[string]any) (string, error) {
|
|
id := c.requestID()
|
|
if err := c.send(map[string]any{"id": id, "method": "thread/start", "params": params}); err != nil {
|
|
return "", err
|
|
}
|
|
return codexThreadIDFromResult(c.waitResponse(ctx, id))
|
|
}
|
|
|
|
func (c *codexAppServerClient) resumeThread(ctx context.Context, params map[string]any) (string, error) {
|
|
id := c.requestID()
|
|
if err := c.send(map[string]any{"id": id, "method": "thread/resume", "params": params}); err != nil {
|
|
return "", err
|
|
}
|
|
return codexThreadIDFromResult(c.waitResponse(ctx, id))
|
|
}
|
|
|
|
func (c *codexAppServerClient) runTurn(ctx context.Context, threadID, text string, onDelta func(string)) (string, error) {
|
|
id := c.requestID()
|
|
if err := c.send(map[string]any{
|
|
"id": id,
|
|
"method": "turn/start",
|
|
"params": map[string]any{
|
|
"input": []map[string]string{{"type": "text", "text": text}},
|
|
"threadId": threadID,
|
|
},
|
|
}); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
var acc strings.Builder
|
|
for {
|
|
msg, err := c.next(ctx)
|
|
if err != nil {
|
|
return "", c.withStderr("app-server stream ended before turn/completed", err)
|
|
}
|
|
if msg.ID != nil && msg.Method != "" {
|
|
c.rejectServerRequest(*msg.ID, msg.Method)
|
|
continue
|
|
}
|
|
if msg.ID != nil && *msg.ID == id && msg.Error != nil {
|
|
return "", fmt.Errorf("turn/start: %s", msg.Error.Message)
|
|
}
|
|
switch msg.Method {
|
|
case "item/agentMessage/delta":
|
|
var p struct {
|
|
Delta string `json:"delta"`
|
|
ThreadID string `json:"threadId"`
|
|
}
|
|
if json.Unmarshal(msg.Params, &p) == nil && p.ThreadID == threadID && p.Delta != "" {
|
|
acc.WriteString(p.Delta)
|
|
if onDelta != nil {
|
|
onDelta(acc.String())
|
|
}
|
|
}
|
|
case "turn/completed":
|
|
final, status, errMsg, ok := codexTurnCompletedText(msg.Params, threadID)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if status == "failed" {
|
|
if errMsg == "" {
|
|
errMsg = "turn failed"
|
|
}
|
|
return "", fmt.Errorf("%s", errMsg)
|
|
}
|
|
if final == "" {
|
|
final = strings.TrimSpace(acc.String())
|
|
}
|
|
if final == "" {
|
|
return "", fmt.Errorf("turn completed without agent message")
|
|
}
|
|
return final, nil
|
|
case "error":
|
|
return "", fmt.Errorf("app-server error notification: %s", truncateRunes(string(msg.Params), 300))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *codexAppServerClient) requestID() int {
|
|
id := c.nextID
|
|
c.nextID++
|
|
return id
|
|
}
|
|
|
|
func (c *codexAppServerClient) send(v any) error {
|
|
b, err := json.Marshal(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = fmt.Fprintln(c.stdin, string(b))
|
|
return err
|
|
}
|
|
|
|
func (c *codexAppServerClient) waitResponse(ctx context.Context, id int) (json.RawMessage, error) {
|
|
for {
|
|
msg, err := c.next(ctx)
|
|
if err != nil {
|
|
return nil, c.withStderr("app-server exited before response", err)
|
|
}
|
|
if msg.ID != nil && msg.Method != "" {
|
|
c.rejectServerRequest(*msg.ID, msg.Method)
|
|
continue
|
|
}
|
|
if msg.ID == nil || *msg.ID != id {
|
|
continue
|
|
}
|
|
if msg.Error != nil {
|
|
return nil, fmt.Errorf("%s", msg.Error.Message)
|
|
}
|
|
return msg.Result, nil
|
|
}
|
|
}
|
|
|
|
func (c *codexAppServerClient) next(ctx context.Context) (codexRPCMessage, error) {
|
|
// The read loop reports EOF before closing msgs, so when the process
|
|
// exits right after its last frame both channels are ready and select
|
|
// would pick one at random — drain buffered frames (e.g. the final
|
|
// turn/completed) before honoring a read error.
|
|
select {
|
|
case msg, ok := <-c.msgs:
|
|
if !ok {
|
|
return codexRPCMessage{}, io.EOF
|
|
}
|
|
return msg, nil
|
|
default:
|
|
}
|
|
select {
|
|
case msg, ok := <-c.msgs:
|
|
if !ok {
|
|
return codexRPCMessage{}, io.EOF
|
|
}
|
|
return msg, nil
|
|
case err := <-c.readErr:
|
|
return codexRPCMessage{}, err
|
|
case <-c.done:
|
|
return codexRPCMessage{}, io.EOF
|
|
case <-ctx.Done():
|
|
return codexRPCMessage{}, ctx.Err()
|
|
}
|
|
}
|
|
|
|
func (c *codexAppServerClient) rejectServerRequest(id int, method string) {
|
|
_ = c.send(map[string]any{
|
|
"id": id,
|
|
"error": map[string]any{
|
|
"code": -32000,
|
|
"message": "DWS robot connect does not support interactive Codex app-server request: " + method,
|
|
},
|
|
})
|
|
}
|
|
|
|
func (c *codexAppServerClient) withStderr(prefix string, err error) error {
|
|
stderr := strings.TrimSpace(c.stderr.String())
|
|
if stderr == "" {
|
|
return fmt.Errorf("%s: %w", prefix, err)
|
|
}
|
|
return fmt.Errorf("%s: %w: %s", prefix, err, truncateRunes(stderr, 300))
|
|
}
|
|
|
|
func codexThreadIDFromResult(result json.RawMessage, err error) (string, error) {
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var r struct {
|
|
Thread struct {
|
|
ID string `json:"id"`
|
|
} `json:"thread"`
|
|
}
|
|
if err := json.Unmarshal(result, &r); err != nil {
|
|
return "", err
|
|
}
|
|
if r.Thread.ID == "" {
|
|
return "", fmt.Errorf("app-server response missing thread.id")
|
|
}
|
|
return r.Thread.ID, nil
|
|
}
|
|
|
|
func codexTurnCompletedText(params json.RawMessage, wantThreadID string) (final, status, errMsg string, ok bool) {
|
|
var p struct {
|
|
ThreadID string `json:"threadId"`
|
|
Turn struct {
|
|
Status string `json:"status"`
|
|
Error *struct {
|
|
Message string `json:"message"`
|
|
AdditionalDetails string `json:"additionalDetails"`
|
|
} `json:"error"`
|
|
Items []struct {
|
|
Type string `json:"type"`
|
|
Text string `json:"text"`
|
|
} `json:"items"`
|
|
} `json:"turn"`
|
|
}
|
|
if err := json.Unmarshal(params, &p); err != nil || p.ThreadID != wantThreadID {
|
|
return "", "", "", false
|
|
}
|
|
for i := len(p.Turn.Items) - 1; i >= 0; i-- {
|
|
if p.Turn.Items[i].Type == "agentMessage" && strings.TrimSpace(p.Turn.Items[i].Text) != "" {
|
|
final = strings.TrimSpace(p.Turn.Items[i].Text)
|
|
break
|
|
}
|
|
}
|
|
if p.Turn.Error != nil {
|
|
errMsg = strings.TrimSpace(p.Turn.Error.Message)
|
|
if p.Turn.Error.AdditionalDetails != "" {
|
|
errMsg = strings.TrimSpace(errMsg + ": " + p.Turn.Error.AdditionalDetails)
|
|
}
|
|
}
|
|
return final, p.Turn.Status, errMsg, true
|
|
}
|