一条 Prompt 的奇幻漂流

export type MessageReceiveContext<TMessage = unknown> = {
  id: string;
  channel: string;
  accountId?: string;
  message: TMessage;
  ackPolicy: MessageAckPolicy;
  ackState: MessageAckState;
  signal: AbortSignal;
  shouldAckAfter(stage: MessageAckStage): boolean;
  ack(): Promise<void>;
  nack(error: unknown): Promise<void>;
};

export function classifyChannelInboundEvent(
  params: ClassifyChannelInboundEventParams,
): InboundEventKind {
  if (params.unmentionedGroupPolicy !== "room_event") {
    return "user_request";
  }
  if (params.conversation.kind !== "group" && params.conversation.kind !== "channel") {
    return "user_request";
  }
  if (
    params.wasMentioned === true ||
    params.hasControlCommand === true ||
    params.commandSource === "native"
  ) {
    return "user_request";
  }
  return "room_event";
}

// dmScope 控制私聊的隔离粒度：
// "main"     → 所有私聊共用一条 session
// "per-peer" → 每个发送者各自一条 session
if (dmScope === "per-peer" && peerId) {
  return `agent:${normalizeAgentId(params.agentId)}:direct:${peerId}`;
}
// 群聊 / 频道：
return `agent:${normalizeAgentId(params.agentId)}:${channel}:${peerKind}:${peerId}`;

return enqueueSession(() => {
  throwIfAborted();
  return enqueueGlobal(async () => {
    throwIfAborted();
    const started = Date.now();
    // ...一次 run 的全部工作都在这两层队列保护下进行
  });
});

const promptAdditions = [
  ackExecutionFastPathInstruction,
  planningOnlyRetryInstruction,
  reasoningOnlyRetryInstruction,
  emptyResponseRetryInstruction,
  compactionContinuationRetryInstruction,
].filter((v): v is string => typeof v === "string" && v.trim().length > 0);

const prompt = promptAdditions.length > 0
  ? `${basePrompt}\n\n${promptAdditions.join("\n\n")}`
  : basePrompt;

const CONTEXT_FILE_ORDER = new Map<string, number>([
  ["agents.md", 10],
  ["soul.md", 20],
  ["identity.md", 30],
  ["user.md", 40],
  ["tools.md", 50],
  ["bootstrap.md", 60],
  ["memory.md", 70],
]);

async assemble(params: AssembleParams): Promise<AssembleResult> {
  // Pass-through: the existing sanitize -> validate -> limit -> repair
  // pipeline in attempt.ts handles context assembly for the legacy engine.
  return {
    messages: params.messages,
    estimatedTokens: 0, // Caller handles estimation
  };
}

export function limitHistoryTurns(
  messages: AgentMessage[],
  limit: number | undefined,
): AgentMessage[] {
  if (!limit || limit <= 0 || messages.length === 0) {
    return messages;
  }
  let userCount = 0;
  let lastUserIndex = messages.length;
  for (let i = messages.length - 1; i >= 0; i--) {
    if (messages[i].role === "user") {
      userCount++;
      if (userCount > limit) {
        return messages.slice(lastUserIndex);
      }
      lastUserIndex = i;
    }
  }
  return messages;
}

const lines = [
  "You are a personal assistant running inside OpenClaw.",
  "",
  "## Tooling",
  "Available tools are policy-filtered. Names are case-sensitive; call exactly as listed.",
  toolLines.length > 0
    ? toolLines.join("\n")
    : buildOpenClawToolFallbackText({ /* ... */ }),
  "TOOLS.md is usage guidance, not availability.",
  // ...接着依次拼 Execution Bias、Safety、Skills、Workspace、SOUL 等 section
];

// 稳定前缀（身份 / 工具 / 安全 / 工作区 / SOUL...）到此为止
lines.push(SYSTEM_PROMPT_CACHE_BOUNDARY);

// ↓ 边界之下：每轮都在变的频道 / 运行时信息，不进缓存
lines.push(...buildMessagingSection({ /* ... */ }));
lines.push(
  "## Runtime",
  buildRuntimeLine(runtimeInfo, runtimeChannel, runtimeCapabilities, defaultThinkLevel),
);

execute: async (toolCallId, params, signal, onUpdate) => {
  const outcome = await runBeforeToolCallHook({
    toolName, params, toolCallId, ctx, signal,
    approvalMode: hookOptions.approvalMode,
  });
  if (outcome.blocked) {
    if (outcome.kind !== "veto") {
      throw new Error(outcome.reason);
    }
    // 被否决：返回一个「已拦截」结果，根本不碰真正的工具
    return buildBlockedToolResult(outcome);
  }
  // 放行：用钩子可能改写过的参数，调真正的工具
  return realExecute(toolCallId, outcome.adjustedParams ?? params, signal, onUpdate);
};

const params: MessageCreateParamsStreaming = {
  model: model.id,
  messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
  max_tokens: options?.maxTokens ?? model.maxTokens,
  stream: true,
};
if (context.systemPrompt) {
  params.system = [{
    type: "text",
    text: sanitizeSurrogates(context.systemPrompt),
    ...(cacheControl ? { cache_control: cacheControl } : {}),
  }];
}
if (context.tools && context.tools.length > 0) {
  params.tools = convertTools(context.tools, isOAuthToken, /* ... */);
}

return tools.map((tool, index) => {
  const schema = tool.parameters as { properties?: unknown; required?: string[] };
  return {
    // OAuth 时把工具名改写成 Claude Code 官方大小写：Bash / Read / Edit ...
    name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
    description: tool.description,
    input_schema: {
      type: "object",
      properties: schema.properties ?? {},
      required: schema.required ?? [],
    },
    // 只给最后一个工具打缓存标记，省写入次数
    ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
  };
});

while (hasMoreToolCalls || pendingMessages.length > 0) {
  // 1) 调模型，流式收回它的回复
  const message = await streamAssistantResponse(
    currentContext, config, signal, emit, streamFn, runtime,
  );
  // 2) 这一轮模型要调工具吗？
  const toolCalls = message.content.filter((c) => c.type === "toolCall");
  hasMoreToolCalls = false;
  if (toolCalls.length > 0) {
    const executed = await executeToolCalls(currentContext, message, config, signal, emit);
    hasMoreToolCalls = !executed.terminate;
    // 3) 把工具结果作为新消息「回灌」——下一轮自动带给模型
    for (const result of executed.messages) {
      currentContext.messages.push(result);
    }
  }
}

export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
  enabled: true,
  reserveTokens: 16384,    // 给摘要输出和 prompt 框架留的安全余量
  keepRecentTokens: 20000, // 压缩时原样保留的最近内容量
};

export function shouldCompact(
  contextTokens: number,
  contextWindow: number,
  settings: CompactionSettings,
): boolean {
  if (!settings.enabled) return false;
  return contextTokens > contextWindow - settings.reserveTokens;
}

export const SILENT_REPLY_TOKEN = "NO_REPLY";

// 整形时：如果整条回复就是这个哨兵，清空它，于是什么都不会发出
const isSilent = isSilentReplyPayloadText(text, silentToken);
if (isSilent) {
  text = "";
}

// 推理块同样会被整条剔除（不进入发送计划）
export function shouldSuppressReasoningPayload(payload: ReplyPayload): boolean {
  return payload.isReasoning === true;
}