// agent.ts
const result: Record<string, Info> = {
  build: {
    name: "build",
    description: "The default agent. Executes tools based on configured permissions.",
    mode: "primary",       // primary(메인) vs subagent(서브)
    permission: [...],     // 어떤 툴을 쓸 수 있는지
    options: {},
    native: true,
  },
  explore: {
    name: "explore",
    mode: "subagent",
    permission: PermissionNext.merge(
      defaults,
      PermissionNext.fromConfig({
        "*": "deny",      // 기본은 다 막고
        grep: "allow",    // 이것만 허용
        glob: "allow",
        read: "allow",
        bash: "allow",
        // edit, write 등은 없음 → 수정 불가
      }),
    ),
    prompt: PROMPT_EXPLORE,  // 전용 시스템 프롬프트
    ...
  },
}

// opencode.jsonc
{
  "agent": {
    "my-reviewer": {
      "description": "코드 리뷰 전문 에이전트",
      "prompt": "You are a strict code reviewer...",
      "permission": {
        "*": "deny",
        "read": "allow",
        "glob": "allow",
      },
    },
  },
}

// tool.ts - 툴 정의 인터페이스
export namespace Tool {
  export interface Info {
    id: string;
    init: (ctx?: InitContext) => Promise<{
      description: string; // LLM에게 보여주는 툴 설명
      parameters: z.ZodType; // 입력 스키마 (Zod)
      execute(
        args,
        ctx,
      ): Promise<{
        title: string;
        metadata: any;
        output: string; // 툴 실행 결과 (LLM에게 전달)
      }>;
    }>;
  }
}

// bash.ts (요약)
export const BashTool = Tool.define("bash", {
  description: "셸 명령어를 실행합니다...",
  parameters: z.object({
    command: z.string(),
    timeout: z.number().optional(),
    description: z.string().optional(),
  }),
  execute: async (args, ctx) => {
    // 권한 확인
    await ctx.ask({ permission: "bash", ... })
 
    // 실제 명령 실행
    const result = await $`${args.command}`.timeout(args.timeout)
 
    return {
      title: args.description ?? args.command,
      output: result.stdout + result.stderr,
      metadata: { exitCode: result.exitCode }
    }
  }
})

export const loop = fn(LoopInput, async (input) => {
  const { sessionID } = input
  let step = 0
 
  while (true) {
    // 1. 현재까지의 메시지 히스토리 가져오기
    const msgs = await MessageV2.filterCompacted(MessageV2.stream(sessionID))
 
    // 2. 마지막 유저/어시스턴트 메시지 확인
    let lastUser, lastAssistant, lastFinished
    // ... (히스토리에서 찾는 로직)
 
    // 3. 특수 케이스 처리
    if (task?.type === "subtask") {
      // 서브에이전트 실행
      await TaskTool.execute(...)
      continue
    }
 
    if (task?.type === "compaction") {
      // 컨텍스트 압축
      await SessionCompaction.process(...)
      continue
    }
 
    if (isContextOverflow) {
      // 자동 압축 트리거
      await SessionCompaction.create(...)
      continue
    }
 
    // 4. 일반 처리: LLM 호출
    step++
    const processor = SessionProcessor.create({ ... })
    const result = await processor.process({
      messages: MessageV2.toModelMessages(msgs, model),
      tools: await resolveTools(...),
      model,
      ...
    })
 
    // 5. 결과에 따라 분기
    if (result === "stop") break           // LLM이 완료 선언
    if (result === "compact") {
      await SessionCompaction.create(...)  // 압축 후 계속
    }
    // result === "continue" → while 반복
  }
})

for await (const value of stream.fullStream) {
  switch (value.type) {
 
    case "text-start":
      // 텍스트 응답 시작 → TextPart 생성
      currentText = { type: "text", text: "", ... }
      await Session.updatePart(currentText)
      break
 
    case "text-delta":
      // 텍스트 스트리밍 중 → DB에 실시간 업데이트
      currentText.text += value.text
      await Session.updatePartDelta({ delta: value.text, ... })
      break
 
    case "tool-call":
      // LLM이 툴 호출 결정 → ToolPart를 running 상태로
      await Session.updatePart({
        type: "tool",
        tool: value.toolName,
        state: { status: "running", input: value.input, ... }
      })
 
      // "doom loop" 감지: 같은 툴을 같은 인자로 3번 반복하면 사용자에게 확인
      if (isDoomLoop) {
        await PermissionNext.ask({ permission: "doom_loop", ... })
      }
      break
 
    case "tool-result":
      // 툴 실행 완료 → ToolPart를 completed 상태로
      await Session.updatePart({
        state: { status: "completed", output: value.output, ... }
      })
      break
 
    case "finish-step":
      // LLM 스텝 완료 → 토큰/비용 계산 및 저장
      const usage = Session.getUsage({ model, usage: value.usage })
      assistantMessage.cost += usage.cost
 
      // 컨텍스트 오버플로우 체크
      if (await SessionCompaction.isOverflow({ tokens: usage.tokens, model })) {
        needsCompaction = true
      }
      break
  }
}

// LLM이 이렇게 호출한다
task({
  description: "Find all API endpoints",
  subagent_type: "explore", // 어떤 에이전트 타입?
  prompt: "Find all REST API endpoints in the codebase...",
});

export const TaskTool = Tool.define("task", async (ctx) => {
  return {
    execute: async (params, ctx) => {
      // 1. 새 자식 세션 생성
      const session = await Session.create({
        parentID: ctx.sessionID,    // 부모 세션 연결
        title: params.description + ` (@${agent.name} subagent)`,
        permission: [
          // 서브에이전트는 또 다른 서브에이전트 호출 불가
          { permission: "task", pattern: "*", action: "deny" },
        ],
      })
 
      // 2. 서브에이전트 실행 (재귀적으로 SessionPrompt.prompt 호출)
      const result = await SessionPrompt.prompt({
        sessionID: session.id,
        agent: agent.name,    // explore, general 등
        parts: promptParts,
      })
 
      // 3. 결과 텍스트 반환 (부모 LLM에게)
      const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
      return {
        output: `task_id: ${session.id}\n\n<task_result>\n${text}\n</task_result>`,
        ...
      }
    }
  }
})

// 컨텍스트가 꽉 찼을 때 자동 실행
export async function isOverflow(input: { tokens; model }) {
  const context = input.model.limit.context;
  const count = input.tokens.total;
  const reserved = Math.min(20_000, maxOutputTokens);
  const usable = context - maxOutputTokens;
 
  return count >= usable; // 한계에 도달했으면 true
}

// 권한 규칙 예시
{
  "*": "allow",          // 기본: 다 허용
  "doom_loop": "ask",    // 무한루프 감지 시: 물어보기
  "bash": "ask",         // bash: 매번 물어보기
  "read": {
    "*": "allow",
    "*.env": "ask",               // .env 파일: 물어보기
    "*.env.example": "allow",     // .env.example은 그냥 허용
  },
  "edit": {
    "*": "deny",                          // plan 에이전트는 수정 금지
    ".opencode/plans/*.md": "allow",      // 플랜 파일만 허용
  },
}

// 이벤트 발행 (서버 쪽)
await Bus.publish(MessageV2.Event.PartUpdated, {
  part: updatedPart, // 툴 실행 결과
});
 
// 이벤트 구독 (UI 쪽)
Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
  // 화면 실시간 업데이트
  updateUI(event.properties.part);
});