opencode — Nghiên cứu sâu các kỹ thuật Harness

while (true) { yield* status.set(sessionID, { type: "busy" }) yield*
        slog.info("loop", { step }) let msgs = yield*
        MessageV2.filterCompactedEffect(sessionID) // Detect
        finish condition — check AFTER tool execution, not before if (lastAssistant?.finish && !["tool-calls"].includes(lastAssistant.finish)
        && !hasToolCalls && lastUser.id < lastAssistant.id) {
        yield* slog.info("exiting
        loop") break } step++ const result = yield*
        handle.process(streamInput) if (result === "stop") return "break" if (result === "compact") yield*
        compaction.create(...) }

// Naive (wrong): while
        (true) { const resp =
        await llm.call(messages) if (resp.finishReason === "stop") break // may exit with unfinished tool_calls! for (const tc of resp.toolCalls) messages.push(executeToolCall(tc))
        } // Opencode-style (correct): while (true) { const resp = await
        llm.call(messages) const hasToolCalls =
        resp.toolCalls.length > 0 if (hasToolCalls) {
        for (const tc of resp.toolCalls) messages.push(executeToolCall(tc))
        continue // always loop again
        after executing tools } if (["stop", "end_turn"].includes(resp.finishReason)) break }

const handleEvent = Effect.fnUntraced(function* (value: StreamEvent) { switch (value.type) { case
        "reasoning-start": ctx.reasoningMap[value.id] =
        { id: PartID.ascending(), text: "", time: {
        start: Date.now() } } yield*
        session.updatePart(ctx.reasoningMap[value.id]); return case "reasoning-delta": ctx.reasoningMap[value.id].text +=
        value.text yield* session.updatePartDelta({
        .../* delta */, delta: value.text }); return case "tool-input-start": const
        part = yield* session.updatePart({ status: "pending", input: {} }) ctx.toolcalls[value.id] = {
        done: yield* Deferred.make<void>(), partID: part.id } return case "tool-call": yield*
        updateToolCall(value.toolCallId, (m) => ({ ...m, status: "running", input: value.input })) // Doom loop check — see T6 return } })

// session/processor.ts:544-554 const stream = llm.stream(streamInput) yield* stream.pipe( Stream.tap((event) =>
        handleEvent(event)), Stream.takeUntil(() => ctx.needsCompaction),
        Stream.runDrain, )

// Demultiplex stream events by type: async function processStream(stream:
        AsyncIterable<Event>, ctx: Context) { for
        await (const ev of stream) { switch (ev.type)
        { case "text-delta":
        ctx.onText?.(ev.delta); break case "tool-input-start":
        ctx.pendingTools.set(ev.id, new Deferred()); break case "tool-call": ctx.onToolCall?.(ev); break case "finish": ctx.finish = ev.finishReason; break } if (ctx.shouldStop)
        break // cooperative
        cancel } }

type ToolCall = { partID:
        MessageV2.ToolPart["id"] messageID:
        MessageV2.ToolPart["messageID"] sessionID:
        MessageV2.ToolPart["sessionID"] done:
        Deferred.Deferred<void> // ← sync point } ctx.toolcalls: Record<string, ToolCall> = {} // On
        tool-input-start event: ctx.toolcalls[value.id] = { done: yield* Deferred.make<void>(), partID: part.id } //
        Tool executor completes it: yield*
        Deferred.succeed(done, undefined) // Cleanup waits for all in-flight tools (but with
        timeout): yield* Effect.forEach(
        Object.values(ctx.toolcalls), (call) =>
        Deferred.await(call.done).pipe(Effect.timeout("250
        millis"), Effect.ignore), { concurrency: "unbounded" }, )

// Using native Promise as deferred: const pendingTools = new
        Map<string, { resolve: () => void;
        promise: Promise<void> }>() function trackToolCall(id: string) { let resolve!: () => void
        const promise = new
        Promise<void>((r) => { resolve = r })
        pendingTools.set(id, { resolve, promise }) } async
        function waitForAllTools(timeoutMs = 250) { const promises = [...pendingTools.values()].map((p)
        => Promise.race([p.promise, new Promise((res)
        => setTimeout(res, timeoutMs))]) ) await
        Promise.all(promises) pendingTools.clear() }

return yield*
        Effect.gen(function* () { yield* Effect.gen(function* ()
        { ctx.currentText = undefined ctx.reasoningMap =
        {} const stream = llm.stream(streamInput) yield* stream.pipe( Stream.tap((event) =>
        handleEvent(event)), Stream.takeUntil(() => ctx.needsCompaction),
        Stream.runDrain, ) }).pipe( Effect.onInterrupt(() => Effect.gen(function* () { aborted = true
        if (!ctx.assistantMessage.error) { yield* halt(new
        DOMException("Aborted", "AbortError")) } })), Effect.catchCauseIf( (cause)
        => !Cause.hasInterruptsOnly(cause), (cause) =>
        Effect.fail(Cause.squash(cause)), ), Effect.retry(...),
        Effect.catch(halt), Effect.ensuring(cleanup()), // ←
        always runs ) })

// Vanilla JS với try/finally: async function streamWithCleanup(signal: AbortSignal)
        { const ctx = createContext() try { for await (const ev of llm.stream({ signal })) { if (signal.aborted) throw new
        DOMException("Aborted", "AbortError") await
        handleEvent(ev, ctx) } } catch (err) { if ((err as Error).name ===
        "AbortError") ctx.markAborted() else throw err } finally {
        await ctx.finalizeAllPendingTools() // always runs } }

if (step > 1 && lastFinished) { for (const m of msgs) { if (m.info.role !==
        "user" || m.info.id <= lastFinished.id)
        continue for (const p of m.parts) { if (p.type !== "text" ||
        p.ignored || p.synthetic) continue if (!p.text.trim()) continue
        p.text = [ "<system-reminder>", "The user sent the following message:", p.text, "", "Please address this message
        and continue with your tasks.", "</system-reminder>", ].join("\n") } } }

function markMidTurnUserMessages(messages:
        Message[], lastAssistantId: string, step: number) { if (step <= 1) return
        messages return messages.map((m) => { if (m.role !== "user" || m.id
        <= lastAssistantId) return m return { ...m, content: `<system-reminder>\nNew message:
        ${m.content}\nPlease
        address.\n</system-reminder>`, } }) }

// Khi thấy tool-call event: case "tool-call": { yield* updateToolCall(value.toolCallId, (m) => ({
        ...m, status: "running", input: value.input }))
        // Doom loop: 3 tool-call cuối cùng giống hệt nhau
        (tên + input) const recentParts =
        parts.slice(-3) if (recentParts.every((p) =>
        p.tool === value.toolName && JSON.stringify(p.state.input) ===
        JSON.stringify(value.input))) { yield*
        permission.ask({ permission: "doom_loop",
        patterns: [value.toolName], always: [], metadata: { input: value.input
        }, }) } return }

const MAX_REPEATS = 3 function isDoomLoop(history: ToolCall[], next:
        ToolCall): boolean { const recent = history.slice(-MAX_REPEATS) if (recent.length < MAX_REPEATS) return false const signature =
        (tc: ToolCall) => `${tc.name}:${JSON.stringify(tc.input)}` const target =
        signature(next) return recent.every((tc) =>
        signature(tc) === target) } // Usage: if (isDoomLoop(history, nextCall)) { const ok = await askUser("Detected repeated tool call. Continue?") if (!ok) throw new Error("Doom loop aborted") }

export const DEFAULT_RESERVED_OUTPUT_TOKENS = 20_000 export function
        computeUsable(modelLimit: number, reserved =
        DEFAULT_RESERVED_OUTPUT_TOKENS) { return Math.max(0, modelLimit -
        reserved) } /** * Tổng token context = input + cache.read + cache.write.
        * Với Anthropic, cache write/read vẫn chiếm chỗ trong context window, *
        nên phải cộng tất cả để đánh giá overflow chính xác. */ export function
        totalContextTokens(usage: Usage): number { return (usage.input ?? 0) +
        (usage.cache?.read ?? 0) + (usage.cache?.write ?? 0) } export function
        shouldCompact(usage: Usage, modelLimit: number, reserved?: number) {
        const usable = computeUsable(modelLimit, reserved) const used =
        totalContextTokens(usage) return used >= usable }

interface Usage { input: number output: number cache?: { read: number;
        write: number } } const RESERVED_OUTPUT = 20_000 // luôn chừa cho
        completion function needsCompaction(usage: Usage, contextWindow:
        number): boolean { const total = usage.input + (usage.cache?.read ?? 0)
        + (usage.cache?.write ?? 0) const threshold = contextWindow -
        RESERVED_OUTPUT return total >= threshold } // Sử dụng sau mỗi lần
        gọi model if (needsCompaction(lastUsage, model.contextWindow)) { await
        compactConversation(session) }

// Budget cho "đuôi" giữ nguyên không compact const tailBudget =
        Math.min( Math.max(Math.floor(usable * 0.25), 2_000), 8_000, ) // Duyệt
        từ cuối ngược lên, giữ lại các turn cho tới khi vượt budget const tail:
        Message[] = [] let tailTokens = 0 for (let i = messages.length - 1; i
        >= 0; i--) { const turnTokens = countTokens(messages[i]) if
        (tailTokens + turnTokens > tailBudget && tail.length >=
        MIN_TAIL) break tail.unshift(messages[i]) tailTokens += turnTokens } //
        Compact phần đầu thành summary const head = messages.slice(0,
        messages.length - tail.length) const summary = await model.complete({
        system: COMPACTION_PROMPT, messages: head, }) return [ { role: "system",
        content:
        `<prior-conversation-summary>\n${summary}\n</prior-conversation-summary>`
        }, ...tail, ]

async function compactWithTail(messages: Msg[], usableTokens: number) {
        const tailBudget = Math.min(Math.max(usableTokens * 0.25, 2000), 8000)
        let tailTokens = 0 const tail: Msg[] = [] for (let i = messages.length -
        1; i >= 0; i--) { const t = countTokens(messages[i]) if (tailTokens +
        t > tailBudget && tail.length >= 2) break
        tail.unshift(messages[i]) tailTokens += t } const head =
        messages.slice(0, messages.length - tail.length) const summary = await
        summarize(head) // 1 lần gọi LLM cho phần đầu return
        [systemSummary(summary), ...tail] // ghép lại }

const PROTECTED_TOOLS = new Set(["skill"]) // skill output đắt → giữ
        nguyên function pruneToolOutputs(messages: Message[]): Message[] { //
        Không prune 2 user turn cuối → model cần xem tool output gần nhất để
        hành động const recentUserTurnIndices =
        findLastUserTurnIndices(messages, 2) const skipBoundary =
        recentUserTurnIndices[0] ?? messages.length return messages.map((msg,
        idx) => { if (idx >= skipBoundary) return msg if (msg.role !==
        "tool") return msg if (PROTECTED_TOOLS.has(msg.toolName)) return msg //
        Thay output bằng placeholder + metadata đánh dấu đã compact return {
        ...msg, content: `<tool-output-compacted tool="${msg.toolName}"
        />`, metadata: { ...msg.metadata, time: { compacted: Date.now() } },
        } }) }

const PROTECTED = new Set(["skill", "memory"]) function
        pruneOldToolOutputs(msgs: Msg[]): Msg[] { const recentBoundary =
        lastNUserTurns(msgs, 2) // giữ nguyên 2 turn cuối return msgs.map((m, i)
        => { if (i >= recentBoundary) return m if (m.role !== "tool" ||
        PROTECTED.has(m.toolName)) return m return { ...m, content:
        `[${m.toolName} output compacted]`, metadata: { compactedAt: Date.now()
        }, } }) }

// system prompt được split thành [header, rest]: // - header: phần
        static (identity, rules, tool descriptions) → cache được // - rest: phần
        dynamic (env block, git status, skills list) → ephemeral function
        buildSystem(model: Model, ctx: Ctx): [string, string] { const header =
        renderTemplate(getModelTemplate(model)) // reusable const rest = [
        buildEnvBlock(ctx), // <env>directory, platform...</env>
        buildSkillsList(ctx.skills), buildProjectInstructions(ctx), // AGENTS.md
        ].join("\n\n") return [header, rest] } // Khi gọi API, đặt cache_control
        vào cuối header const systemBlocks = [ { type: "text", text: header,
        cache_control: { type: "ephemeral" } }, { type: "text", text: rest }, //
        không cache ]

// Anthropic message format await anthropic.messages.create({ model:
        "claude-sonnet-4", system: [ { type: "text", text: STATIC_SYSTEM_PROMPT,
        // >~1024 tokens để đủ cache cache_control: { type: "ephemeral" }, //
        breakpoint }, { type: "text", text: dynamicEnvBlock }, // không cache ],
        messages, tools: [...TOOLS, { /* last tool */ cache_control: { type:
        "ephemeral" } }], })

// Sau khi compact xong, phải "nhắc" model tiếp tục task đang dở async
        function continueAfterCompaction(session: Session, lastUserMsg: Message)
        { if (lastUserMsg.hasMedia()) { // Media không thể replay → inject text
        description return injectSyntheticUser(session,
        describeMedia(lastUserMsg)) } if (isUserMessage(lastUserMsg) &&
        !lastUserMsg.answered) { // User message chưa được trả lời → replay
        nguyên văn return replayMessage(session, lastUserMsg) } // Model đang ở
        giữa task nhưng không có user message mới → prompt continue return
        injectSyntheticUser(session, "continue", { metadata: {
        compaction_continue: true }, }) }

async function resumeAfterCompaction(session: Session) { const last =
        session.lastMessage() if (last?.role === "user" &&
        !last.responded) { // user vừa hỏi, model chưa kịp trả lời → replay
        await session.sendMessage(last) return } // Model đang làm giữa chừng →
        bơm "continue" await session.sendSystem({ content: "continue", metadata:
        { kind: "compaction-continue" }, }) }

const DEFAULT_COMPACTION_TEMPLATE = ` You are compacting a coding agent
        conversation. Produce a dense summary with these sections: ## Goal One
        sentence describing what the user ultimately wants. ## Instructions
        Bullet list of rules the user gave (tone, constraints, tech choices). ##
        Discoveries Facts learned about the codebase: file paths, symbols,
        patterns, gotchas. ## Accomplished What has been done so far (edits,
        commands, decisions). ## Relevant files List of files with 1-line
        description each. Be factual. No filler. Max ${MAX_SUMMARY_TOKENS}
        tokens. ` // Plugin có thể override: const template =
        plugins.compactionTemplate?.() ?? DEFAULT_COMPACTION_TEMPLATE

const COMPACTION_TEMPLATE = ` Summarize the conversation above. Use
        EXACTLY these sections: ### Goal (1 sentence) ### Constraints (bullet
        list — user's rules/preferences) ### Relevant files (file path + 1 line)
        ### Done (what actions have been performed) ### Next (what remains)
        `.trim() async function compact(history: Msg[]) { return llm.complete({
        system: COMPACTION_TEMPLATE, messages: history, maxTokens: 2000, }) }

// tool/bash.ts import DESCRIPTION from "./bash.txt" import { Tool }
        from "./tool" export const BashTool = Tool.define("bash", { description:
        renderTemplate(DESCRIPTION, { PLATFORM: process.platform, SHELL:
        process.env.SHELL, MAX_LINES: 2000, }), parameters: z.object({ command:
        z.string(), timeout: z.number().optional(), }), // ... })

# tool/bash.txt (excerpt) Execute shell commands in a persistent {SHELL}
        session on {PLATFORM}. <important-rules> - DO NOT use `find` or
        `grep` — use the dedicated Grep/Glob tools instead. - Quote paths with
        spaces. - Output is truncated to {MAX_LINES} lines.
        </important-rules>

// edit.ts import DESCRIPTION from "./edit.txt" export const EditTool =
        defineTool({ name: "edit", description: DESCRIPTION
        .replace("{MAX_FILE_SIZE}", String(MAX_FILE_SIZE))
        .replace("{READ_REQUIREMENT}", "You MUST Read the file first"), schema:
        editSchema, handler: editHandler, })

export namespace Tool { export const define = <P extends z.ZodType,
        R>( id: string, init: Effect.Effect<Definition<P, R>, never,
        Truncate | Agent>, ) => { return Effect.gen(function* () { const
        def = yield* init // resolve services ONCE at definition time const
        truncate = yield* Truncate const agent = yield* Agent // Return a
        wrapped version that intercepts execute for truncation + tracing return
        wrap(id, def, truncate, agent) }) } function wrap<P, R>(id:
        string, def: Definition<P, R>, truncate: Truncate, agent: Agent) {
        return { ...def, execute: (args: z.infer<P>, ctx: ExecuteCtx)
        => Effect.withSpan(`Tool.execute`, { attributes: { "tool.name": id }
        })( def.execute(args, ctx).pipe( Effect.tap((result) =>
        truncate.apply(id, result)), ), ), } } }

function defineTool<A>(id: string, factory: (deps: Deps) =>
        ToolDef<A>) { const deps = resolveDeps() // inject once const base
        = factory(deps) return { ...base, execute: async (args: A, ctx: Ctx)
        => { const span = tracer.startSpan(`tool.${id}`) try { const raw =
        await base.execute(args, ctx) return deps.truncate(raw) // auto truncate
        } finally { span.end() } }, } }

const MAX_LINES = 2_000 const MAX_BYTES = 50_000 export function
        truncateOutput( output: string, opts: { direction?: "head" | "tail";
        toolName: string; callId: string } = {}, ) { const { direction = "tail",
        toolName, callId } = opts const lines = output.split("\n") if
        (lines.length <= MAX_LINES && output.length <= MAX_BYTES)
        return output // Giữ lại "tail" (hoặc head) theo direction const keep =
        direction === "tail" ? lines.slice(-MAX_LINES).join("\n") :
        lines.slice(0, MAX_LINES).join("\n") // Ghi full output ra file để agent
        có thể đọc lại bằng Read/Grep const spillPath =
        `/tmp/opencode-overflow/${toolName}-${callId}.txt`
        fs.writeFileSync(spillPath, output) return `${keep}
        <truncated-notice> Output truncated to last ${MAX_LINES} lines.
        Full output saved to ${spillPath}. Use the Read or Grep tool to access
        specific parts. </truncated-notice>` }

async function truncateAndSpill( output: string, meta: { tool: string;
        callId: string }, ): Promise<string> { if (output.length <=
        50_000) return output const tail = output.slice(-50_000) const path =
        `/tmp/agent-overflow/${meta.tool}-${meta.callId}.log` await
        fs.writeFile(path, output) return tail + `\n\n[Output was
        ${output.length} bytes, truncated to last 50k. ` + `Full content:
        ${path}. Use Read/Grep to inspect.]` }

function validateArgs<P extends z.ZodType>(parameters: P, raw:
        unknown): z.infer<P> { const parsed = parameters.safeParse(raw) if
        (!parsed.success) { const issues = parsed.error.issues .map((i) =>
        `${i.path.join(".")}: ${i.message}`) .join("; ") throw new ToolArgError(
        `Please rewrite the input with valid arguments. Errors: ${issues}`, ) }
        return parsed.data }

import { z } from "zod" const EditArgs = z.object({ file_path:
        z.string().min(1), old_string: z.string(), new_string: z.string(), })
        function validateEdit(raw: unknown) { const r = EditArgs.safeParse(raw)
        if (!r.success) { const details = r.error.issues .map(i =>
        `${i.path.join(".")}: ${i.message}`) .join("; ") throw new Error(`Please
        rewrite the input. Errors: ${details}`) } return r.data }

// 3 tier, try từ strict → loose const REPLACERS = [ SimpleReplacer, //
        exact match LineTrimmedReplacer, // ignore leading/trailing whitespace
        per line BlockAnchorReplacer, // match first + last line, fuzzy middle ]
        as const export async function applyEdit(content: string, oldStr:
        string, newStr: string) { for (const replacer of REPLACERS) { const
        match = replacer.findMatch(content, oldStr) if (match) { return
        replacer.replace(content, match, newStr) } } throw new
        NoMatchError("old_string not found in file") } // BlockAnchorReplacer:
        match dòng đầu + dòng cuối của block, // rồi Levenshtein distance các
        dòng giữa với threshold class BlockAnchorReplacer { static
        findMatch(content: string, oldStr: string) { const oldLines =
        oldStr.split("\n") if (oldLines.length < 3) return null // chỉ áp
        dụng block >= 3 dòng const first = oldLines[0].trim() const last =
        oldLines[oldLines.length - 1].trim() const candidates =
        findAllAnchorPairs(content, first, last) const scored =
        candidates.map((c) => ({ ...c, score: levenshteinRatio(oldStr,
        content.slice(c.start, c.end)), })) scored.sort((a, b) => b.score -
        a.score) const threshold = scored.length > 1 ? 0.3 : 0.0 return
        scored[0]?.score >= threshold ? scored[0] : null } }

const replacers = [exactMatch, trimmedMatch, anchorMatch] function
        replaceFlex(content: string, oldStr: string, newStr: string) { for
        (const r of replacers) { const m = r.find(content, oldStr) if (m) return
        content.slice(0, m.start) + newStr + content.slice(m.end) } throw new
        Error("No match found. Re-read the file and retry.") } function
        anchorMatch(content: string, oldStr: string) { const lines =
        oldStr.split("\n") if (lines.length < 3) return null const [first,
        ...rest] = lines const last = rest.pop()! // Tìm tất cả anchor pairs,
        chọn cặp có Levenshtein ratio cao nhất // ... }

import TreeSitter from "web-tree-sitter" import BashWasm from
        "tree-sitter-bash/tree-sitter-bash.wasm" with { type: "file" } //
        Lazy-load parser một lần let parserPromise:
        Promise<TreeSitter.Parser> | null = null function getParser() { if
        (!parserPromise) { parserPromise = (async () => { await
        TreeSitter.init() const parser = new TreeSitter()
        parser.setLanguage(await TreeSitter.Language.load(BashWasm)) return
        parser })() } return parserPromise } const DESTRUCTIVE_COMMANDS = new
        Set(["rm", "mv", "cp", "dd", "chmod", "chown"]) export async function
        analyzeCommand(cmd: string) { const parser = await getParser() const
        tree = parser.parse(cmd) const commands: Array<{ name: string; args:
        string[]; paths: string[] }> = [] walkTree(tree.rootNode, (node)
        => { if (node.type === "command") { const name =
        node.childForFieldName("name")?.text ?? "" const args =
        node.childrenForFieldName("argument").map((a) => a.text) const paths
        = args.filter((a) => looksLikePath(a)) commands.push({ name, args,
        paths }) } }) return { commands, modifiesFiles: commands.some((c) =>
        DESTRUCTIVE_COMMANDS.has(c.name)), } }

// Simplified: detect các command modify file async function
        extractDangerousPaths(cmd: string): Promise<string[]> { const tree
        = await parseBash(cmd) const paths: string[] = [] walk(tree.rootNode,
        (node) => { if (node.type !== "command") return const name =
        node.childForFieldName("name")?.text if (!DESTRUCTIVE.has(name)) return
        for (const arg of node.namedChildren) { if (arg.type === "word"
        && looksLikePath(arg.text)) paths.push(arg.text) } }) return
        paths }

export const TaskTool = Tool.define("task", Effect.gen(function* () {
        const ops = yield* Session.Ops return { description: TASK_DESCRIPTION,
        parameters: z.object({ description: z.string().describe("3-5 word task
        summary"), prompt: z.string(), subagent_type: z.enum(["general-purpose",
        "explore", "plan"]).default("general-purpose"), }), async execute(args,
        ctx) { // Child session thừa hưởng permission rules nhưng với
        restrictions const childSession = yield*
        ops.createChildSession(ctx.sessionId, { agent: args.subagent_type,
        inheritPermissions: true, deniedTools: ["task", "todowrite"], // prevent
        recursion / scope creep }) // Recursive: gọi lại ops.prompt() trên child
        session const result = yield* ops.prompt(childSession.id, { message:
        args.prompt, description: args.description, }) return { summary:
        result.finalMessage.text, toolCalls: result.toolCalls.length,
        tokensUsed: result.usage.total, } }, } }))

async function spawnSubAgent(opts: { prompt: string type: "explore" |
        "plan" parent: Session }) { const child = await createSession({ agent:
        opts.type, system: getAgentSystem(opts.type), permissions:
        inheritFrom(opts.parent).deny(["task", "todowrite"]), parent:
        opts.parent.id, }) const result = await runLoop(child, opts.prompt)
        return { summary: result.finalText, // ONLY summary gửi về parent cost:
        result.cost, } }

export async function discoverPluginTools(configDirs: string[]) { const
        tools: Tool[] = [] for (const dir of configDirs) { const files = await
        glob("{tool,tools}/*.{js,ts,mjs}", { cwd: dir, absolute: true }) for
        (const file of files) { try { const mod = await import(file) const
        toolDef = mod.default ?? mod.tool if (!toolDef) continue // Wrap với
        fromPlugin: auto-truncate + sandboxed permission
        tools.push(Tool.fromPlugin(toolDef, { source: file })) } catch (err) {
        log.warn(`Plugin tool load failed: ${file}`, err) } } } return tools }

import { glob } from "fast-glob" import { pathToFileURL } from
        "node:url" async function loadUserTools(pluginDirs: string[]):
        Promise<Tool[]> { const out: Tool[] = [] for (const dir of
        pluginDirs) { const files = await glob(["tool/*.{js,ts}",
        "tools/*.{js,ts}"], { cwd: dir }) for (const f of files) { const mod =
        await import(pathToFileURL(f).href) const def = mod.default if
        (def?.name && def?.execute) { out.push(wrapTool(def)) //
        auto-apply truncate / perm / trace } } } return out }

// Mỗi provider = 1 dynamic import lazy const BUNDLED_PROVIDERS:
        Record<string, () => Promise<Loader>> = { anthropic: ()
        => import("./loaders/anthropic").then((m) => m.default), openai:
        () => import("./loaders/openai").then((m) => m.default), google:
        () => import("./loaders/google").then((m) => m.default), bedrock:
        () => import("./loaders/bedrock").then((m) => m.default), mistral:
        () => import("./loaders/mistral").then((m) => m.default), groq: ()
        => import("./loaders/groq").then((m) => m.default), // ... 15+
        more } export async function loadProvider(id: string):
        Promise<Loader> { const loader = BUNDLED_PROVIDERS[id] if
        (!loader) throw new UnknownProviderError(id) return await loader() //
        import chỉ khi user thật sự dùng }

const LOADERS = { anthropic: () => import("@anthropic-ai/sdk"),
        openai: () => import("openai"), google: () =>
        import("@google/generative-ai"), } as const async function
        getClient(provider: keyof typeof LOADERS) { const mod = await
        LOADERS[provider]() return mod.default }

// Anthropic: tool_use phải tách khỏi text content function
        anthropicTransform(msgs: Message[]): AnthropicMessage[] { return
        msgs.flatMap((m) => { if (m.role !== "assistant") return [m as
        AnthropicMessage] const toolUses = m.content.filter((c) => c.type ===
        "tool_use") const nonTool = m.content.filter((c) => c.type !==
        "tool_use") // Split nếu có cả hai if (toolUses.length &&
        nonTool.length) { return [ { role: "assistant", content: nonTool }, {
        role: "assistant", content: toolUses }, ] } return [m as
        AnthropicMessage] }) } // Mistral: toolCallId max 9 chars, alphanumeric
        function mistralTransform(msgs: Message[]) { return msgs.map((m) =>
        ({ ...m, content: m.content.map((c) => { if ("toolCallId" in c) {
        return { ...c, toolCallId: padToolCallId(c.toolCallId) } // truncate +
        pad } return c }), })) } // Claude sanitize: alphanumeric only trong
        tool name function sanitizeClaudeToolName(name: string): string { return
        name.replace(/[^a-zA-Z0-9_-]/g, "_") }

const TRANSFORMS: Record<Provider, Transform> = { anthropic:
        splitToolUse, openai: identity, mistral: truncateToolCallIds, google:
        moveSystemToStart, } function callModel(provider: Provider, msgs: Msg[])
        { const transform = TRANSFORMS[provider] ?? identity const prepared =
        transform(msgs) return getClient(provider).chat.completions.create({
        messages: prepared }) }

// 25+ regex patterns detect overflow từ nhiều provider const
        OVERFLOW_PATTERNS: RegExp[] = [ /prompt is too long/i, /exceeds the
        context window/i, /max.*context.*length/i, /context_length_exceeded/i,
        /no body.*(400|413)/i, // Bedrock silent truncation
        /token.*limit.*exceeded/i, // ... 20+ more ] export function
        isContextOverflow(err: unknown): boolean { const msg =
        extractErrorMessage(err) return OVERFLOW_PATTERNS.some((r) =>
        r.test(msg)) } // Retry with server-directed delay export async function
        withRetry<T>(fn: () => Promise<T>, maxAttempts = 5):
        Promise<T> { let attempt = 0 while (true) { try { return await
        fn() } catch (err) { attempt++ if (isContextOverflow(err)) throw err //
        không retry overflow if (attempt >= maxAttempts) throw err // Tôn
        trọng server directive const serverMs = extractRetryAfter(err) //
        retry-after-ms | retry-after const delayMs = serverMs ?? Math.min(2 **
        (attempt - 1) * 2000, 30_000) await sleep(delayMs) } } }

const OVERFLOW = [ /prompt is too long/i, /context.?window/i,
        /token.?limit/i, ] async function retryable<T>(fn: () =>
        Promise<T>, max = 5): Promise<T> { for (let i = 0; i <
        max; i++) { try { return await fn() } catch (e) { const msg = String((e
        as Error).message ?? e) if (OVERFLOW.some(r => r.test(msg))) throw
        new OverflowError(e) // compact, don't retry if (i === max - 1) throw e
        const serverDelay = (e as any).headers?.["retry-after-ms"] const delay =
        serverDelay ?? Math.min(2000 * 2 ** i, 30_000) await new Promise(r =>
        setTimeout(r, +delay)) } } throw new Error("unreachable") }

import { Wildcard } from "./wildcard" export function evaluate( rules:
        PermissionRule[], permission: string, // "bash" | "edit" | "write" | ...
        pattern: string, // "rm -rf *" | "/tmp/**" | ... ): "allow" | "deny" |
        "ask" { const match = rules.findLast((rule) =>
        Wildcard.match(permission, rule.permission) &&
        Wildcard.match(pattern, rule.pattern) ) return match?.action ?? "ask" //
        default "ask" khi không match }

interface Rule { permission: string; pattern: string; action:
        "allow"|"deny"|"ask" } function matchWildcard(value: string, pattern:
        string): boolean { const re = new RegExp("^" + pattern.replace(/\*/g,
        ".*") + "$") return re.test(value) } function evaluate(rules: Rule[],
        perm: string, ptn: string) { const hit = [...rules].reverse().find(r
        => matchWildcard(perm, r.permission) && matchWildcard(ptn,
        r.pattern) ) return hit?.action ?? "ask" }

interface PermissionState { sessionId: string alwaysAllow: Array<{
        permission: string; pattern: string }> // session-scoped pending:
        Map<string, Deferred<"allow" | "deny">> } export class
        Permission { async ask(req: PermissionRequest): Promise<"allow" |
        "deny"> { // 1. Check static rules const staticResult =
        evaluate(this.rules, req.permission, req.pattern) if (staticResult !==
        "ask") return staticResult // 2. Check session alwaysAllow const always
        = this.state.alwaysAllow.some((r) => Wildcard.match(req.permission,
        r.permission) && Wildcard.match(req.pattern, r.pattern) ) if
        (always) return "allow" // 3. Ask user (UI emits event) const deferred =
        makeDeferred() this.state.pending.set(req.id, deferred)
        emit("permission.request", req) return await deferred.promise }
        reply(reqId: string, reply: "once" | "always" | "reject", pattern?:
        string) { const d = this.state.pending.get(reqId) if (!d) return if
        (reply === "always" && pattern) { this.state.alwaysAllow.push({
        permission: d.req.permission, pattern }) } d.resolve(reply === "reject"
        ? "deny" : "allow") } }

class PermissionGate { private alwaysAllow: Array<{perm: string, ptn:
        string}> = [] async ask(req: Request): Promise<"allow"|"deny">
        { if (this.alwaysAllow.some(r => match(req, r))) return "allow" const
        answer = await ui.ask(req) // UI returns {mode, pattern?} if
        (answer.mode === "always") { this.alwaysAllow.push({ perm:
        req.permission, ptn: answer.pattern ?? req.pattern }) } return
        answer.mode === "reject" ? "deny" : "allow" } }

// ARITY map: command → số "word" cần giữ để nhận diện "human command"
        const ARITY: Record<string, number> = { touch: 1, // touch
        file.txt → "touch" ls: 1, // ls -la → "ls" npm: 2, // npm install → "npm
        install" "npm run": 3, // npm run build → "npm run build" "git config":
        3, "pnpm dlx": 3, "npx create-next-app": 4, // ... 450+ entries } export
        function normalizeCommand(raw: string): string { const tokens =
        tokenize(raw) // respect quotes // Try longest prefix match for (let n =
        4; n >= 1; n--) { const prefix = tokens.slice(0, n).join(" ") if
        (ARITY[prefix] === n) { return tokens.slice(0, n).join(" ") } } return
        tokens[0] ?? "" // fallback: first token } // normalizeCommand("npm run
        build --watch") === "npm run build" // normalizeCommand("git config
        --global user.email [email protected]") === "git config --global user.email"? //
        ... thực chất sẽ là "git config" với arity=3 nhưng token[2] là
        "--global" // → opencode xử lý kỹ hơn, bỏ qua flags

const ARITY: Record<string, number> = { ls: 1, cat: 1, touch: 1,
        mkdir: 1, "npm install": 2, "npm run": 3, "git status": 2, "git add": 2,
        "git commit": 2, "docker run": 2, "docker compose": 2, } function
        normalize(cmd: string): string { const parts = cmd.split(/\s+/).filter(p
        => !p.startsWith("-")) for (let n = 3; n >= 1; n--) { const pref =
        parts.slice(0, n).join(" ") if (ARITY[pref] === n) return pref } return
        parts[0] ?? "" }

import PROMPT_ANTHROPIC from "./prompts/anthropic.txt" import PROMPT_GPT
        from "./prompts/gpt.txt" import PROMPT_BEAST from "./prompts/beast.txt"
        // gpt-4 | o1 import PROMPT_GEMINI from "./prompts/gemini.txt" import
        PROMPT_DEFAULT from "./prompts/default.txt" function
        pickTemplate(modelId: string): string { if
        (/^(gpt-4|o1|o3)/i.test(modelId)) return PROMPT_BEAST if
        (/^gpt/i.test(modelId)) return PROMPT_GPT if (/^gemini/i.test(modelId))
        return PROMPT_GEMINI if (/claude/i.test(modelId)) return
        PROMPT_ANTHROPIC return PROMPT_DEFAULT } export function
        buildSystem(model: Model, ctx: Ctx): string[] { const template =
        pickTemplate(model.id) const envBlock = ` <env> directory:
        ${ctx.cwd} worktree: ${ctx.worktree} git: ${ctx.gitStatusShort}
        platform: ${process.platform} </env> ` const skillsBlock =
        renderSkills(ctx.skills, { permissionGate: ctx.perm }) const
        projectBlock = ctx.agentsFile ?? "" return [template, envBlock,
        skillsBlock, projectBlock] }

const PROMPTS = { anthropic: ANTHROPIC_TEMPLATE, openai:
        OPENAI_TEMPLATE, gemini: GEMINI_TEMPLATE, } function systemFor(model:
        string, ctx: Ctx) { const template = PROMPTS[detectFamily(model)] ??
        DEFAULT_TEMPLATE const env = `<env>cwd=${ctx.cwd}; git=${ctx.git};
        os=${process.platform}</env>` return [template, env,
        ctx.projectInstructions ?? ""].join("\n\n") }

const INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"]
        export async function findProjectInstructions(cwd: string, worktree:
        string) { let dir = path.resolve(cwd) const stop =
        path.resolve(worktree) while (dir.startsWith(stop)) { for (const name of
        INSTRUCTION_FILES) { const candidate = path.join(dir, name) if (await
        fs.pathExists(candidate)) { return { path: candidate, content: await
        fs.readFile(candidate, "utf8") } } } const parent = path.dirname(dir) if
        (parent === dir) break // reached root dir = parent } return null } //
        Per-message "claims tracking" prevent duplicate attach const
        attachedFiles = new Set<string>() export function
        attachInstructionIfNew(file: InstructionFile) { if
        (attachedFiles.has(file.path)) return null // already in conversation
        attachedFiles.add(file.path) return `<project-instruction
        src="${file.path}">\n${file.content}\n</project-instruction>` }

async function findInstructions(cwd: string, repoRoot: string) { let dir
        = cwd while (dir.startsWith(repoRoot)) { for (const name of
        ["AGENTS.md", "CLAUDE.md"]) { const p = path.join(dir, name) if (await
        exists(p)) return { path: p, body: await readFile(p, "utf8") } } const
        parent = path.dirname(dir) if (parent === dir) break dir = parent }
        return null } const attached = new Set<string>() function
        buildInstructionBlock(f: { path: string; body: string }) { if
        (attached.has(f.path)) return "" attached.add(f.path) return
        `<project-instructions
        src="${f.path}">\n${f.body}\n</project-instructions>` }