@downcity/agent 1.1.18 → 1.1.20

package/src/runtime/server/http/control/SessionRoutes.ts

@@ -30,6 +30,7 @@ import {
   toUiMessageTimeline,
 } from "./Helpers.js";
 import { executeBySessionId } from "./ExecuteBySession.js";
+import { createControlSessionStreamResponse } from "./StreamBySession.js";
 const CONSOLEUI_SESSION_ID = "consoleui-chat-main";
 
 function normalizeSystemText(input: string | null | undefined): string {
@@ -411,4 +412,31 @@ export function registerControlSessionRoutes(
       }
     });
   }
+
+  for (const routePath of buildControlRouteAliases("/sessions/:sessionId/stream")) {
+    app.post(routePath, async (c) => {
+      try {
+        const runtime = params.getAgentRuntime();
+        const sessionId = decodeMaybe(String(c.req.param("sessionId") || "").trim());
+        const body = (await c.req.json().catch(() => ({}))) as Partial<ControlSessionExecuteRequestBody>;
+        const instructions = String(body.instructions || "").trim();
+        if (!sessionId) {
+          return c.json({ success: false, error: "Missing sessionId" }, 400);
+        }
+        if (!instructions) {
+          return c.json({ success: false, error: "Missing instructions" }, 400);
+        }
+
+        return await createControlSessionStreamResponse({
+          agentState: runtime,
+          executionContext: params.getAgentContext(),
+          sessionId,
+          instructions,
+          attachments: Array.isArray(body.attachments) ? body.attachments : undefined,
+        });
+      } catch (error) {
+        return c.json({ success: false, error: String(error) }, 500);
+      }
+    });
+  }
 }

package/src/runtime/server/http/control/StreamBySession.ts

@@ -0,0 +1,198 @@
+/**
+ * Control session 流式执行 helper。
+ *
+ * 关键点（中文）
+ * - 仅用于单 agent control API 的本地 session 流式返回。
+ * - chatKey 命中的平台 chat 队列仍保持原有入队语义，不在这里伪造“流式完成”。
+ * - 输出协议复用 SDK `AgentSessionStreamEvent` 的 NDJSON 事件行，便于 CLI 直接消费。
+ */
+
+import type { AgentContext, SessionPort } from "@/core/AgentContextTypes.js";
+import type { AgentRuntime } from "@/core/AgentCoreTypes.js";
+import type {
+  ControlSessionExecuteAttachmentInput,
+} from "@/runtime/server/http/control/types/ControlSessionExecute.js";
+import { buildExecuteInputText } from "@/runtime/server/http/control/Helpers.js";
+import { drainDeferredPersistedUserMessages } from "@session/SessionRunScope.js";
+import { mapUiMessageChunkToSdkEvent } from "@/sdk/StreamEvents.js";
+import type { AgentSessionStreamEvent } from "@/sdk/AgentSdkTypes.js";
+import type {
+  SessionRunResult,
+  SessionUiMessageChunkCallback,
+} from "@/session/types/SessionRun.js";
+import { resolveDispatchTargetByChatKey } from "@/service/builtins/chat/runtime/ChatkeySend.js";
+import {
+  pickLastSuccessfulChatSendText,
+  resolveAssistantMessageForPersistence,
+} from "@/service/builtins/chat/runtime/UserVisibleText.js";
+
+type StreamableSessionPort = SessionPort & {
+  /**
+   * 流式执行当前 session。
+   *
+   * 说明（中文）
+   * - `SessionPort` 对外接口当前未显式暴露 `onUiMessageChunkCallback`，
+   *   但本地 executor 已支持该回调，这里按本地 control runtime 语义做窄化使用。
+   */
+  run(params: {
+    query: string;
+    onUiMessageChunkCallback?: SessionUiMessageChunkCallback;
+  }): Promise<SessionRunResult>;
+};
+
+const NDJSON_CONTENT_TYPE = "application/x-ndjson; charset=utf-8";
+
+function encodeNdjsonLine(
+  encoder: TextEncoder,
+  value: AgentSessionStreamEvent,
+): Uint8Array {
+  return encoder.encode(`${JSON.stringify(value)}\n`);
+}
+
+function resolveStreamEventFromUiChunk(params: {
+  chunk: Parameters<NonNullable<SessionUiMessageChunkCallback>>[0];
+  toolNameByCallId: Map<string, string>;
+}): AgentSessionStreamEvent | null {
+  const { chunk, toolNameByCallId } = params;
+  if (chunk.type === "tool-input-start") {
+    toolNameByCallId.set(chunk.toolCallId, chunk.toolName);
+    return null;
+  }
+
+  const event = mapUiMessageChunkToSdkEvent(chunk);
+  if (!event) return null;
+
+  if (event.type === "tool-call" || event.type === "tool-error") {
+    toolNameByCallId.set(event.toolCallId, event.toolName);
+  }
+
+  if (
+    (event.type === "tool-result" || event.type === "tool-error") &&
+    event.toolName === "unknown"
+  ) {
+    const toolName = toolNameByCallId.get(event.toolCallId);
+    return toolName ? { ...event, toolName } : event;
+  }
+
+  return event;
+}
+
+/**
+ * 为指定 session 创建流式执行响应。
+ */
+export async function createControlSessionStreamResponse(params: {
+  agentState: AgentRuntime;
+  executionContext: AgentContext;
+  sessionId: string;
+  instructions: string;
+  attachments?: ControlSessionExecuteAttachmentInput[];
+}): Promise<Response> {
+  const sessionId = String(params.sessionId || "").trim();
+  const instructions = String(params.instructions || "").trim();
+  if (!sessionId) {
+    return Response.json({ success: false, error: "Missing sessionId" }, { status: 400 });
+  }
+  if (!instructions) {
+    return Response.json({ success: false, error: "Missing instructions" }, { status: 400 });
+  }
+
+  const executeInput = await buildExecuteInputText({
+    projectRoot: params.agentState.rootPath,
+    sessionId,
+    instructions,
+    attachments: params.attachments,
+  });
+
+  const dispatchTarget = await resolveDispatchTargetByChatKey({
+    context: params.executionContext,
+    chatKey: sessionId,
+  });
+  if (dispatchTarget) {
+    return Response.json(
+      {
+        success: false,
+        error:
+          "Streaming execute does not support queued chat sessions. Use the non-stream execute API for chatKey routes.",
+      },
+      { status: 409 },
+    );
+  }
+
+  const session = params.agentState.getSession(sessionId) as StreamableSessionPort;
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      void (async () => {
+        const toolNameByCallId = new Map<string, string>();
+
+        const pushEvent = (event: AgentSessionStreamEvent): void => {
+          controller.enqueue(encodeNdjsonLine(encoder, event));
+        };
+
+        try {
+          await session.appendUserMessage({
+            text: executeInput,
+          });
+
+          const result = await session.run({
+            query: executeInput,
+            onUiMessageChunkCallback: async (chunk) => {
+              const event = resolveStreamEventFromUiChunk({
+                chunk,
+                toolNameByCallId,
+              });
+              if (!event) return;
+              pushEvent(event);
+            },
+          });
+
+          const userVisible = pickLastSuccessfulChatSendText(
+            result.assistantMessage,
+          ).trim();
+          try {
+            const messageForPersistence = resolveAssistantMessageForPersistence(
+              result.assistantMessage,
+            );
+            if (messageForPersistence) {
+              await session.appendAssistantMessage({
+                message: messageForPersistence,
+                fallbackText: userVisible,
+                extra: {
+                  via: "tui_session_stream",
+                  note: "assistant_message_missing",
+                },
+              });
+            }
+            const deferredInjectedMessages = drainDeferredPersistedUserMessages(
+              sessionId,
+            );
+            for (const message of deferredInjectedMessages) {
+              await session.appendUserMessage({
+                message,
+              });
+            }
+          } catch {
+            // ignore persistence follow-up errors after stream completion
+          }
+        } catch (error) {
+          pushEvent({
+            type: "error",
+            error: error instanceof Error ? error.message : String(error),
+          });
+        } finally {
+          controller.close();
+        }
+      })();
+    },
+  });
+
+  return new Response(stream, {
+    status: 200,
+    headers: {
+      "Content-Type": NDJSON_CONTENT_TYPE,
+      "Cache-Control": "no-cache, no-transform",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

package/src/session/Executor.ts

@@ -617,7 +617,10 @@ export class Executor implements SessionExecutor {
           textOnlyContinuationCount += 1;
           incompleteResponseRecoveryCount = 0;
           const continuationMessage = this.historyStore.userText({
-            text: buildTextOnlyContinuationNudge(textOnlyContinuationCount),
+            text: buildTextOnlyContinuationNudge(
+              textOnlyContinuationCount,
+              textOnlyContinuationReason,
+            ),
             metadata: {
               sessionId,
               extra: {

package/src/session/core-engine/CoreEngineSignals.ts

@@ -63,6 +63,18 @@ const TEXT_ONLY_CONTINUATION_PATTERNS: ReadonlyArray<{
   name: string;
   pattern: RegExp;
 }> = [
+  {
+    name: "pseudo_tool_protocol_dsml",
+    pattern: /<\s*｜｜DSML｜｜(?:tool_calls|invoke|parameter)\b/i,
+  },
+  {
+    name: "pseudo_tool_protocol_ascii",
+    pattern: /<\s*(?:tool_calls?|function_call|invoke)\b/i,
+  },
+  {
+    name: "pseudo_tool_protocol_json",
+    pattern: /"tool_calls"\s*:\s*\[/i,
+  },
   { name: "zh_start_now", pattern: /我现在开始/ },
   { name: "zh_next_will", pattern: /接下来我会/ },
   { name: "zh_will_do", pattern: /我会(?:先|继续|开始|基于|按)/ },
@@ -405,8 +417,19 @@ export function detectTextOnlyContinuationReason(
  */
 export function buildTextOnlyContinuationNudge(
   continuationIndex: number,
+  reason?: string | null,
 ): string {
   const round = Math.max(1, continuationIndex);
+  const normalizedReason = String(reason || "").trim();
+  if (normalizedReason.startsWith("pseudo_tool_protocol")) {
+    return [
+      `系统续跑提醒（第 ${round} 次）：上一轮输出了伪工具调用协议文本，但没有产生真实工具调用。`,
+      "不要把 DSML、XML、JSON tool_calls 或任何工具协议当作普通正文输出。",
+      "如果确实需要工具，请立刻使用当前运行时提供的原生工具重新发起调用；只能使用实际可用的工具名。",
+      "如果目标工具不可用，请明确说明不可用，并改用可用工具完成任务或说明受阻原因。",
+      "只有在任务真正完成、明确受阻、或必须等待用户提供信息时才停止。",
+    ].join("\n");
+  }
   return [
     `系统续跑提醒（第 ${round} 次）：继续执行当前任务。`,
     "不要只描述计划、下一步或“我接下来会做什么”。",