会话管理架构

// 格式：agent:{agentId}[:mainKey|channel:peerKind:peerId]

// 示例：
agent:main:                           // 主会话
agent:main:custom                      // 自定义主键
agent:main:telegram:dm:123456789       // Telegram DM
agent:main:whatsapp:dm:+1234567890    // WhatsApp DM
agent:main:discord:group:123456      // Discord 群组
agent:work:telegram:dm:123456789        // Work Agent 的 Telegram DM

export type ChatRunState = {
  runId: string;              // 运行 ID
  sessionKey: string;          // 会话键
  sessionId: string;           // 会话 ID
  agentId: string;            // Agent ID
  startedAt: number;          // 开始时间
  message?: string;           // 触发消息
  lane?: string;              // 队列名
  aborted?: boolean;          // 是否中止
};

export function limitHistoryTurns(
  messages: Message[],
  limit?: number,
  modelContextWindow?: number
): Message[] {
  // 1. 如果无限制，返回所有
  if (!limit && !modelContextWindow) return messages;

  // 2. 按 user 限制
  if (limit) {
    let userTurnCount = 0;
    const result: Message[] = [];
    for (let i = messages.length - 1; i >= 0; i--) {
      const msg = messages[i];
      result.unshift(msg);
      if (msg.role === "user") {
        userTurnCount++;
        if (userTurnCount >= limit) break;
      }
    }
    return result;
  }

  // 3. 按上下文窗口限制
  if (modelContextWindow) {
    // ... 估算 token 数并修剪
  }

  return messages;
}

export async function compactEmbeddedPiSession(
  sessionFile: string,
  opts: {
    provider?: string;
    model?: string;
    reason?: string;
  }
): Promise<EmbeddedPiCompactResult> {
  // 1. 读取当前会话
  const { sessionManager, session } = await readSession(sessionFile);

  // 2. 生成摘要
  const summary = await generateSummary({
    session,
    provider,
    model,
  });

  // 3. 重置会话为摘要
  await session.resetLeaf();

  // 4. 注入摘要作为 system message
  await session.append({
    role: "user",
    content: `<context_summary>\n${summary}\n</context_summary>`,
  });

  return {
    success: true,
    summary,
    messageCount: messageCount,
  };
}

// 调用 compact 方法
await gatewayCall({
  method: "sessions.compact",
  params: {
    sessionKey: "agent:main",
    reason: "Manual compaction"
  }
});

// 会话文件存储路径
export function resolveStorePath(
  sessionKey: string,
  workspaceDir?: string
): string {
  const agentDir = resolveAgentDir(sessionKey, workspaceDir);
  return path.join(agentDir, "sessions.jsonl");
}

// Agent 目录
export function resolveAgentDir(
  sessionKey: string,
  workspaceDir?: string
): string {
  const [_, agentId] = sessionKey.split(":");
  const resolvedWorkspaceDir = workspaceDir ?? resolveDefaultWorkspaceDir();
  return path.join(resolvedWorkspaceDir, ".clawdbot", "agents", agentId);
}

// 防止同一 session 并发
const sessionLane = resolveSessionLane(params.sessionKey ?? params.sessionId);

// 全局资源限制
const globalLane = resolveGlobalLane(params.lane);

// 执行时排队
return enqueueSessionLane(() =>
  enqueueGlobalLane(async () => {
    // 实际执行
  })
);

// Session lane 格式：session:{key}
resolveSessionLane("agent:main")
// → "session:agent:main"

// Global lane 格式：可配置
resolveGlobalLane("main")
// → "main"

// 更新会话属性
await gatewayCall({
  method: "sessions.patch",
  params: {
    sessionKey: "agent:main",
    patch: {
      thinkingLevel: "high",
      verboseLevel: true,
      sendPolicy: "auto",
      model: "anthropic/claude-opus-4-5"
    }
  }
});

export type SessionEventType =
  | "session_start"
  | "session_end"
  | "session_reset"
  | "session_compact";

export type SessionEvent = {
  type: SessionEventType;
  sessionKey: string;
  sessionId?: string;
  timestamp: Date;
  context?: Record<string, unknown>;
};

// 监听会话开始
registerInternalHook('session_start', async (event) => {
  console.log('Session started:', event.sessionKey);
});

// 监听会话结束
registerInternalHook('session_end', async (event) => {
  console.log('Session ended:', event.sessionKey);
});