OpenCode
从源码学会它怎么工作

 1081      const runLoop: (sessionID: SessionID) => Effect.Effect<SessionV1.WithParts> = Effect.fn("SessionPrompt.run")(
 1082        function* (sessionID: SessionID) {
 1083          const ctx = yield* InstanceState.context
 1084          let structured: unknown
 1085          let step = 0
 1086          const session = yield* sessions.get(sessionID).pipe(Effect.orDie)
 1087  
 1088          while (true) {
 1089            yield* status.set(sessionID, { type: "busy" })
 1090            yield* Effect.logInfo("loop", { "session.id": sessionID, step })
 1091  
 1092            let msgs = yield* MessageV2.filterCompactedEffect(sessionID).pipe(
 1093              Effect.provideService(Database.Service, database),
 1094            )
 1095  
 1096            const { user: lastUser, assistant: lastAssistant, finished: lastFinished, tasks } = MessageV2.latest(msgs)
 1097  
 1098            if (!lastUser) throw new Error("No user message found in stream. This should never happen.")
 1099  
 1100            const lastAssistantMsg = msgs.findLast(
 1101              (msg) => msg.info.role === "assistant" && msg.info.id === lastAssistant?.id,
 1102            )
 1103            // Some providers return "stop" even when the assistant message contains
 1104            // tool calls. Keep the loop running so tool results can be sent back to
 1105            // the model, but ignore cleanup-marked interrupted orphans.
      … 14 lines omitted; exact range 1081–1130 …
 1120              if (orphan) {
 1121                yield* Effect.logWarning("loop exit with orphaned interrupted tool", {
 1122                  "session.id": sessionID,
 1123                  messageID: lastAssistant.id,
 1124                  tool: orphan.tool,
 1125                  callID: orphan.callID,
 1126                })
 1127              }
 1128              yield* Effect.logInfo("exiting loop", { "session.id": sessionID })
 1129              break
 1130            }

 1170            const agent = yield* agents.get(lastUser.agent)
 1171            if (!agent) {
 1172              const available = (yield* agents.list()).filter((a) => !a.hidden).map((a) => a.name)
 1173              const hint = available.length ? ` Available agents: ${available.join(", ")}` : ""
 1174              const error = new NamedError.Unknown({ message: `Agent not found: "${lastUser.agent}".${hint}` })
 1175              yield* events.publish(Session.Event.Error, { sessionID, error: error.toObject() })
 1176              throw error
 1177            }
 1178            const maxSteps = agent.steps ?? Infinity
 1179            const isLastStep = step >= maxSteps
 1180            msgs = yield* SessionReminders.apply({ messages: msgs, agent, session }).pipe(
 1181              Effect.provideService(RuntimeFlags.Service, flags),
 1182              Effect.provideService(FSUtil.Service, fsys),
 1183              Effect.provideService(Session.Service, sessions),
 1184            )
 1185  
 1186            const msg: SessionV1.Assistant = {
 1187              id: MessageID.ascending(),
 1188              parentID: lastUser.id,
 1189              role: "assistant",
 1190              mode: agent.name,
 1191              agent: agent.name,
 1192              variant: lastUser.model.variant,
 1193              path: { cwd: ctx.directory, root: ctx.worktree },
 1194              cost: 0,
      … 36 lines omitted; exact range 1170–1241 …
 1231                bypassAgentCheck,
 1232                messages: msgs,
 1233                promptOps,
 1234              }).pipe(
 1235                Effect.provideService(Plugin.Service, plugin),
 1236                Effect.provideService(Permission.Service, permission),
 1237                Effect.provideService(ToolRegistry.Service, registry),
 1238                Effect.provideService(MCP.Service, mcp),
 1239                Effect.provideService(Truncate.Service, truncate),
 1240                Effect.provideService(RuntimeFlags.Service, flags),
 1241              )

  539        const cleanup = Effect.fn("SessionProcessor.cleanup")(function* () {
  540          if (ctx.snapshot) {
  541            const patch = yield* snapshot.patch(ctx.snapshot)
  542            if (patch.files.length) {
  543              yield* session.updatePart({
  544                id: PartID.ascending(),
  545                messageID: ctx.assistantMessage.id,
  546                sessionID: ctx.sessionID,
  547                type: "patch",
  548                hash: patch.hash,
  549                files: patch.files,
  550              })
  551            }
  552            ctx.snapshot = undefined
  553          }
  554  
  555          if (ctx.currentText) {
  556            const end = Date.now()
  557            ctx.currentText.time = { start: ctx.currentText.time?.start ?? end, end }
  558            yield* session.updatePart(ctx.currentText)
  559            ctx.currentText = undefined
  560          }
  561  
  562          for (const part of Object.values(ctx.reasoningMap)) {
  563            const end = Date.now()
      … 23 lines omitted; exact range 539–597 …
  587                status: "error",
  588                error: "Tool execution aborted",
  589                metadata: { ...metadata, interrupted: true },
  590                time: { start: "time" in part.state ? part.state.time.start : end, end },
  591              },
  592            })
  593          }
  594          ctx.toolcalls = {}
  595          ctx.assistantMessage.time.completed = Date.now()
  596          yield* session.updateMessage(ctx.assistantMessage)
  597        })

  315            case "tool-input-start":
  316              if (ctx.assistantMessage.summary) {
  317                throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
  318              }
  319              yield* ensureToolCall(value)
  320              return
  321  
  322            case "tool-input-delta":
  323              yield* ensureToolCall(value)
  324              return
  325  
  326            case "tool-input-end": {
  327              yield* ensureToolCall(value)
  328              return
  329            }
  330  
  331            case "tool-call": {
  332              if (ctx.assistantMessage.summary) {
  333                throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
  334              }
  335              yield* ensureToolCall(value)
  336              const input = isRecord(value.input) ? value.input : { value: value.input }
  337              yield* updateToolCall(value.id, (match) => ({
  338                ...match,
  339                tool: value.name,
      … 63 lines omitted; exact range 315–413 …
  403              const attachments = normalized.filter(Exit.isSuccess).map((item) => item.value)
  404              const output = {
  405                ...rawOutput,
  406                output:
  407                  omitted === 0
  408                    ? rawOutput.output
  409                    : `${rawOutput.output}\n\n[${omitted} image${omitted === 1 ? "" : "s"} omitted: could not be resized below the image size limit.]`,
  410                attachments: attachments.length ? attachments : undefined,
  411              }
  412              yield* completeToolCall(value.id, output)
  413              return

  101  type BundledSDK = {
  102    languageModel(modelId: string): LanguageModelV3
  103    chat?: (modelId: string) => LanguageModelV3
  104    responses?: (modelId: string) => LanguageModelV3
  105  }
  106  
  107  const BUNDLED_PROVIDERS: Record<string, () => Promise<(opts: any) => BundledSDK>> = {
  108    "@ai-sdk/amazon-bedrock": () => import("@ai-sdk/amazon-bedrock").then((m) => m.createAmazonBedrock),
  109    "@ai-sdk/amazon-bedrock/mantle": () => import("@ai-sdk/amazon-bedrock/mantle").then((m) => m.createBedrockMantle),
  110    "@ai-sdk/anthropic": () => import("@ai-sdk/anthropic").then((m) => m.createAnthropic),
  111    "@ai-sdk/azure": () => import("@ai-sdk/azure").then((m) => m.createAzure),
  112    "@ai-sdk/google": () => import("@ai-sdk/google").then((m) => m.createGoogleGenerativeAI),
  113    "@ai-sdk/google-vertex": () => import("@ai-sdk/google-vertex").then((m) => m.createVertex),
  114    "@ai-sdk/google-vertex/anthropic": () =>
  115      import("@ai-sdk/google-vertex/anthropic").then((m) => m.createVertexAnthropic),
  116    "@ai-sdk/openai": () => import("@ai-sdk/openai").then((m) => m.createOpenAI),
  117    "@ai-sdk/openai-compatible": () => import("@ai-sdk/openai-compatible").then((m) => m.createOpenAICompatible),
  118    "@openrouter/ai-sdk-provider": () => import("@openrouter/ai-sdk-provider").then((m) => m.createOpenRouter),
  119    "@ai-sdk/xai": () => import("@ai-sdk/xai").then((m) => m.createXai),
  120    "@ai-sdk/mistral": () => import("@ai-sdk/mistral").then((m) => m.createMistral),
  121    "@ai-sdk/groq": () => import("@ai-sdk/groq").then((m) => m.createGroq),
  122    "@ai-sdk/deepinfra": () => import("@ai-sdk/deepinfra").then((m) => m.createDeepInfra),
  123    "@ai-sdk/cerebras": () => import("@ai-sdk/cerebras").then((m) => m.createCerebras),
  124    "@ai-sdk/cohere": () => import("@ai-sdk/cohere").then((m) => m.createCohere),
  125    "@ai-sdk/gateway": () => import("@ai-sdk/gateway").then((m) => m.createGateway),
      … 9 lines omitted; exact range 101–145 …
  135  
  136  type CustomModelLoader = (sdk: any, modelID: string, options?: Record<string, any>, model?: Model) => Promise<any>
  137  type CustomVarsLoader = (options: Record<string, any>) => Record<string, string>
  138  type CustomDiscoverModels = () => Promise<Record<string, Model>>
  139  type CustomLoader = (provider: Info) => Effect.Effect<{
  140    autoload: boolean
  141    getModel?: CustomModelLoader
  142    vars?: CustomVarsLoader
  143    options?: Record<string, any>
  144    discoverModels?: CustomDiscoverModels
  145  }>

   56  export const prepare = Effect.fn("LLMRequestPrep.prepare")(function* (input: PrepareInput) {
   57    const isOpenaiOauth = input.provider.id === "openai" && input.auth?.type === "oauth"
   58    const system = [
   59      [
   60        ...(input.agent.prompt ? [input.agent.prompt] : SystemPrompt.provider(input.model)),
   61        ...input.system,
   62        ...(input.user.system ? [input.user.system] : []),
   63      ]
   64        .filter((x) => x)
   65        .join("\n"),
   66    ]
   67  
   68    const header = system[0]
   69    yield* input.plugin.trigger(
   70      "experimental.chat.system.transform",
   71      { sessionID: input.sessionID, model: input.model },
   72      { system },
   73    )
   74    if (system.length > 2 && system[0] === header) {
   75      const rest = system.slice(1)
   76      system.length = 0
   77      system.push(header, rest.join("\n"))
   78    }
   79  
   80    const variant =
      … 9 lines omitted; exact range 56–100 …
   90        })
   91    const options = mergeOptions(mergeOptions(mergeOptions(base, input.model.options), input.agent.options), variant)
   92    if (
   93      input.model.api.npm === "@ai-sdk/azure" &&
   94      (input.provider.options.useCompletionUrls || input.model.options.useCompletionUrls || options.useCompletionUrls)
   95    ) {
   96      delete options.reasoningSummary
   97      delete options.include
   98    }
   99    if (isOpenaiOauth) options.instructions = system.join("\n")
  100  

  257  const parse = Effect.fn("ShellTool.parse")(function* (command: string, ps: boolean) {
  258    const tree = yield* Effect.promise(() => parser().then((p) => (ps ? p.ps : p.bash).parse(command)))
  259    if (!tree) throw new Error("Failed to parse command")
  260    return tree
  261  })
  262  
  263  const ask = Effect.fn("ShellTool.ask")(function* (ctx: Tool.Context, scan: Scan, input: { command: string }) {
  264    if (scan.dirs.size > 0) {
  265      const directories = Array.from(scan.dirs)
  266      const globs = directories.map((dir) => {
  267        if (process.platform === "win32") return FSUtil.normalizePathPattern(path.join(dir, "*"))
  268        return path.join(dir, "*")
  269      })
  270      yield* ctx.ask({
  271        permission: "external_directory",
  272        patterns: globs,
  273        always: globs,
  274        metadata: {
  275          command: input.command,
  276          directories,
  277          patterns: globs,
  278        },
  279      })
  280    }
  281  
  282    if (scan.patterns.size === 0) return
  283    yield* ctx.ask({
  284      permission: ShellID.ToolID,
  285      patterns: Array.from(scan.patterns),
  286      always: Array.from(scan.always),
  287      metadata: {
  288        command: input.command,
  289      },
  290    })
  291  })

   86  const layer = Layer.effect(
   87    Service,
   88    Effect.gen(function* () {
   89      const config = yield* Config.Service
   90      const plugin = yield* Plugin.Service
   91      const agents = yield* Agent.Service
   92      const truncate = yield* Truncate.Service
   93      const flags = yield* RuntimeFlags.Service
   94      const mcp = yield* MCP.Service
   95  
   96      const invalid = yield* InvalidTool
   97      const task = yield* TaskTool
   98      const read = yield* ReadTool
   99      const question = yield* QuestionTool
  100      const todo = yield* TodoWriteTool
  101      const lsptool = yield* LspTool
  102      const plan = yield* PlanExitTool
  103      const webfetch = yield* WebFetchTool
  104      const websearch = yield* WebSearchTool
  105      const shell = yield* ShellTool
  106      const globtool = yield* GlobTool
  107      const writetool = yield* WriteTool
  108      const edit = yield* EditTool
  109      const greptool = yield* GrepTool
  110      const patchtool = yield* ApplyPatchTool
      … 54 lines omitted; exact range 86–175 …
  165                }).pipe(
  166                  Effect.withSpan("Tool.execute", {
  167                    attributes: {
  168                      "tool.name": id,
  169                      "session.id": toolCtx.sessionID,
  170                      "message.id": toolCtx.messageID,
  171                      ...(toolCtx.callID ? { "tool.call_id": toolCtx.callID } : {}),
  172                    },
  173                  }),
  174                ),
  175            }

   35  const locks = new Map<string, Semaphore.Semaphore>()
   36  
   37  function lock(filePath: string) {
   38    const resolvedFilePath = FSUtil.resolve(filePath)
   39    const hit = locks.get(resolvedFilePath)
   40    if (hit) return hit
   41  
   42    const next = Semaphore.makeUnsafe(1)
   43    locks.set(resolvedFilePath, next)
   44    return next
   45  }
   46  
   47  export const Parameters = Schema.Struct({
   48    filePath: Schema.String.annotate({ description: "The absolute path to the file to modify" }),
   49    oldString: Schema.String.annotate({ description: "The text to replace" }),
   50    newString: Schema.String.annotate({
   51      description: "The text to replace it with (must be different from oldString)",
   52    }),
   53    replaceAll: Schema.optional(Schema.Boolean).annotate({
   54      description: "Replace all occurrences of oldString (default false)",
   55    }),
   56  })

  164  export interface Interface {
  165    readonly status: () => Effect.Effect<Record<string, Status>>
  166    readonly clients: () => Effect.Effect<Record<string, MCPClient>>
  167    readonly instructions: () => Effect.Effect<ServerInstructions[]>
  168    readonly tools: () => Effect.Effect<Record<string, McpTool>>
  169    readonly prompts: () => Effect.Effect<Record<string, PromptInfo & { client: string }>>
  170    readonly resources: (clientName?: string) => Effect.Effect<Record<string, ResourceInfo & { client: string }>>
  171    readonly resourceTemplates: (
  172      clientName?: string,
  173    ) => Effect.Effect<Record<string, ResourceTemplateInfo & { client: string }>>
  174    readonly add: (name: string, mcp: ConfigMCPV1.Info) => Effect.Effect<{ status: Record<string, Status> | Status }>
  175    readonly connect: (name: string) => Effect.Effect<void, NotFoundError>
  176    readonly disconnect: (name: string) => Effect.Effect<void, NotFoundError>
  177    readonly getPrompt: (
  178      clientName: string,
  179      name: string,
  180      args?: Record<string, string>,
  181    ) => Effect.Effect<Awaited<ReturnType<MCPClient["getPrompt"]>> | undefined>
  182    readonly readResource: (
  183      clientName: string,
  184      resourceUri: string,
  185    ) => Effect.Effect<Awaited<ReturnType<MCPClient["readResource"]>> | undefined>
  186    readonly startAuth: (
  187      mcpName: string,
  188    ) => Effect.Effect<{ authorizationUrl: string; oauthState: string }, NotFoundError>
  189    readonly authenticate: (
  190      mcpName: string,
  191      onAuthorization?: (authorizationUrl: string) => void,
  192    ) => Effect.Effect<Status, NotFoundError>
  193    readonly finishAuth: (mcpName: string, authorizationCode: string) => Effect.Effect<Status, NotFoundError>
  194    readonly removeAuth: (mcpName: string) => Effect.Effect<void>
  195    readonly supportsOAuth: (mcpName: string) => Effect.Effect<boolean, NotFoundError>
  196    readonly hasStoredTokens: (mcpName: string) => Effect.Effect<boolean>
  197    readonly getAuthStatus: (mcpName: string) => Effect.Effect<AuthStatus>
  198  }

   76    // Normalize a config item into the loader's internal representation.
   77    function plan(item: ConfigPluginV1.Spec): Plan {
   78      const spec = ConfigPlugin.pluginSpecifier(item)
   79      return { spec, options: ConfigPlugin.pluginOptions(item), deprecated: isDeprecatedPlugin(spec) }
   80    }
   81  
   82    // Resolve a configured plugin into a concrete entrypoint that can later be imported.
   83    //
   84    // The stages here intentionally separate install/target resolution, entrypoint detection,
   85    // and compatibility checks so callers can report the exact reason a plugin was skipped.
   86    export async function resolve(
   87      plan: Plan,
   88      kind: PluginKind,
   89    ): Promise<
   90      | { ok: true; value: Resolved }
   91      | { ok: false; stage: "missing"; value: Missing }
   92      | { ok: false; stage: "install" | "entry" | "compatibility"; error: unknown }
   93    > {
   94      // First make sure the plugin exists locally, installing npm plugins on demand.
   95      let target = ""
   96      try {
   97        target = await resolvePluginTarget(plan.spec)
   98      } catch (error) {
   99        return { ok: false, stage: "install", error }
  100      }
      … 33 lines omitted; exact range 76–144 …
  134  
  135    // Import the resolved module only after all earlier validation has succeeded.
  136    export async function load(row: Resolved): Promise<{ ok: true; value: Loaded } | { ok: false; error: unknown }> {
  137      let mod
  138      try {
  139        mod = await import(row.entry)
  140      } catch (error) {
  141        return { ok: false, error }
  142      }
  143      if (!mod) return { ok: false, error: new Error(`Plugin ${row.spec} module is empty`) }
  144      return { ok: true, value: { ...row, mod } }

    8  const COMPACTION_BUFFER = 20_000
    9  
   10  export function usable(input: { cfg: ConfigV1.Info; model: Provider.Model; outputTokenMax?: number }) {
   11    const context = input.model.limit.context
   12    if (context === 0) return 0
   13  
   14    const reserved =
   15      input.cfg.compaction?.reserved ??
   16      Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model, input.outputTokenMax))
   17    return input.model.limit.input
   18      ? Math.max(0, input.model.limit.input - reserved)
   19      : Math.max(0, context - ProviderTransform.maxOutputTokens(input.model, input.outputTokenMax))
   20  }
   21  
   22  export function isOverflow(input: {
   23    cfg: ConfigV1.Info
   24    tokens: SessionV1.Assistant["tokens"]
   25    model: Provider.Model
   26    outputTokenMax?: number
   27  }) {
   28    if (input.cfg.compaction?.auto === false) return false
   29    if (input.model.limit.context === 0) return false
   30  
   31    const count =
   32      input.tokens.total || input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
   33    return count >= usable(input)

   28  export const PRUNE_MINIMUM = 20_000
   29  export const PRUNE_PROTECT = 40_000
   30  const TOOL_OUTPUT_MAX_CHARS = 2_000
   31  const PRUNE_PROTECTED_TOOLS = ["skill"]
   32  const DEFAULT_TAIL_TURNS = 2
   33  const MIN_PRESERVE_RECENT_TOKENS = 2_000
   34  const MAX_PRESERVE_RECENT_TOKENS = 8_000
   35  type Turn = {

  289      const processCompaction = Effect.fn("SessionCompaction.process")(function* (input: {
  290        parentID: MessageID
  291        messages: SessionV1.WithParts[]
  292        sessionID: SessionID
  293        auto: boolean
  294        overflow?: boolean
  295      }) {
  296        const parent = input.messages.findLast((m) => m.info.id === input.parentID)
  297        if (!parent || parent.info.role !== "user") {
  298          throw new Error(`Compaction parent must be a user message: ${input.parentID}`)
  299        }
  300        const userMessage = parent.info
  301        const compactionPart = parent.parts.find((part): part is SessionV1.CompactionPart => part.type === "compaction")
  302  
  303        let messages = input.messages
  304        let replay:
  305          | {
  306              info: SessionV1.User
  307              parts: SessionV1.Part[]
  308            }
  309          | undefined
  310        if (input.overflow) {
  311          const idx = input.messages.findIndex((m) => m.info.id === input.parentID)
  312          for (let i = idx - 1; i >= 0; i--) {
  313            const msg = input.messages[i]
      … 30 lines omitted; exact range 289–354 …
  344          "experimental.session.compacting",
  345          { sessionID: input.sessionID },
  346          { context: [], prompt: undefined },
  347        )
  348        const nextPrompt = compacting.prompt ?? buildPrompt({ previousSummary, context: compacting.context })
  349        const msgs = structuredClone(selected.head)
  350        yield* plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
  351        const modelMessages = yield* MessageV2.toModelMessagesEffect(msgs, model, {
  352          stripMedia: true,
  353          toolOutputMaxChars: TOOL_OUTPUT_MAX_CHARS,
  354        })

   13  const RETENTION = Duration.days(7)
   14  
   15  export const MAX_LINES = 2000
   16  export const MAX_BYTES = 50 * 1024
   17  export const DIR = TRUNCATION_DIR
   18  export const GLOB = path.join(TRUNCATION_DIR, "*")
   19  
   20  export type Result = { content: string; truncated: false } | { content: string; truncated: true; outputPath: string }
   21  
   22  export interface Options {
   23    maxLines?: number
   24    maxBytes?: number
   25    direction?: "head" | "tail"
   26  }
   27  
   28  function hasTaskTool(agent?: Agent.Info) {
   29    if (!agent?.permission) return false
   30    return evaluate("task", "*", agent.permission).action !== "deny"
   31  }
   32  
   33  export interface Interface {
   34    readonly cleanup: () => Effect.Effect<void>
   35    readonly write: (text: string) => Effect.Effect<string>
   36    /**
   37     * Returns output unchanged when it fits within the limits, otherwise writes the full text
   38     * to the truncation directory and returns a preview plus a hint to inspect the saved file.
   39     */
   40    readonly output: (text: string, options?: Options, agent?: Agent.Info) => Effect.Effect<Result>
   41    /**
   42     * Resolved truncation limits: values from `tool_output` in opencode config, or MAX_LINES / MAX_BYTES if unset.
   43     */
   44    readonly limits: () => Effect.Effect<{ maxLines: number; maxBytes: number }>

   28  export function evaluate(permission: string, pattern: string, ...rulesets: PermissionV1.Ruleset[]): PermissionV1.Rule {
   29    return (
   30      rulesets
   31        .flat()
   32        .findLast((rule) => Wildcard.match(permission, rule.permission) && Wildcard.match(pattern, rule.pattern)) ?? {
   33        action: "ask",
   34        permission,
   35        pattern: "*",
   36      }
   37    )

   98      const state = yield* InstanceState.make<State>(
   99        Effect.fn("Agent.state")(function* (ctx) {
  100          const cfg = yield* config.get()
  101          const skillDirs = yield* skill.dirs()
  102          const referenceDirs = Object.keys(cfg.references ?? cfg.reference ?? {}).length
  103            ? yield* Effect.gen(function* () {
  104                yield* (yield* PluginV2.Service).wait(PluginV2.ID.make("core/config-reference"))
  105                return (yield* (yield* Reference.Service).list()).map((reference) => reference.path)
  106              }).pipe(Effect.provide(locations.get(Location.Ref.make({ directory: AbsolutePath.make(ctx.directory) }))))
  107            : []
  108          const whitelistedDirs = [
  109            Truncate.GLOB,
  110            path.join(Global.Path.tmp, "*"),
  111            ...skillDirs.map((dir) => path.join(dir, "*")),
  112            ...referenceDirs.map((dir) => path.join(dir, "*")),
  113          ]
  114          const readonlyExternalDirectory = {
  115            "*": "ask",
  116            ...Object.fromEntries(whitelistedDirs.map((dir) => [dir, "allow"])),
  117          } satisfies Record<string, "allow" | "ask" | "deny">
  118  
  119          const defaults = Permission.fromConfig({
  120            "*": "allow",
  121            doom_loop: "ask",
  122            external_directory: {
      … 22 lines omitted; exact range 98–155 …
  145              permission: Permission.merge(
  146                defaults,
  147                Permission.fromConfig({
  148                  question: "allow",
  149                  plan_enter: "allow",
  150                }),
  151                user,
  152              ),
  153              mode: "primary",
  154              native: true,
  155            },

  331            case "tool-call": {
  332              if (ctx.assistantMessage.summary) {
  333                throw new Error(`Tool call not allowed while generating summary: ${value.name}`)
  334              }
  335              yield* ensureToolCall(value)
  336              const input = isRecord(value.input) ? value.input : { value: value.input }
  337              yield* updateToolCall(value.id, (match) => ({
  338                ...match,
  339                tool: value.name,
  340                state:
  341                  match.state.status === "running"
  342                    ? { ...match.state, input }
  343                    : {
  344                        status: "running",
  345                        input,
  346                        time: { start: Date.now() },
  347                      },
  348                metadata: match.metadata?.providerExecuted
  349                  ? { ...value.providerMetadata, providerExecuted: true }
  350                  : value.providerMetadata,
  351              }))
  352  
  353              const parts = yield* MessageV2.parts(ctx.assistantMessage.id).pipe(
  354                Effect.provideService(Database.Service, database),
  355              )
      … 14 lines omitted; exact range 331–380 …
  370  
  371              const agent = yield* agents.get(ctx.assistantMessage.agent)
  372              yield* permission.ask({
  373                permission: "doom_loop",
  374                patterns: [value.name],
  375                sessionID: ctx.assistantMessage.sessionID,
  376                metadata: { tool: value.name, input },
  377                always: [value.name],
  378                ruleset: agent.permission,
  379              })
  380              return

  293  function cmd(shell: string, command: string, cwd: string, env: NodeJS.ProcessEnv) {
  294    if (process.platform === "win32" && Shell.ps(shell)) {
  295      return ChildProcess.make(shell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command], {
  296        cwd,
  297        env,
  298        stdin: "ignore",
  299        detached: false,
  300      })
  301    }
  302  
  303    return ChildProcess.make(command, [], {
  304      shell,
  305      cwd,
  306      env,
  307      stdin: "ignore",
  308      detached: process.platform !== "win32",
  309    })

  123  function remoteURL(value: string) {
  124    if (URL.canParse(value)) return new URL(value)
  125  }

   60      const globalFiles = [
   61        path.join(global.config, "AGENTS.md"),
   62        ...(!flags.disableClaudeCodePrompt ? [path.join(global.home, ".claude", "CLAUDE.md")] : []),
   63      ]
   64      const instructionFiles = [
   65        "AGENTS.md",
   66        ...(!flags.disableClaudeCodePrompt ? ["CLAUDE.md"] : []),
   67        "CONTEXT.md", // deprecated
   68      ]
   69  
   70      const state = yield* InstanceState.make(
   71        Effect.fn("Instruction.state")(() =>
   72          Effect.succeed({
   73            // Track which instruction files have already been attached for a given assistant message.
   74            claims: new Map<MessageID, Set<string>>(),
   75          }),
   76        ),
   77      )
   78  
   79      const relative = Effect.fnUntraced(function* (instruction: string) {
   80        const ctx = yield* InstanceState.context
   81        if (!Flag.OPENCODE_DISABLE_PROJECT_CONFIG) {
   82          return yield* fs
   83            .globUp(instruction, ctx.directory, ctx.worktree)
   84            .pipe(Effect.catch(() => Effect.succeed([] as string[])))
   85        }
   86        return yield* fs
   87          .globUp(instruction, global.config, global.config)
   88          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
   89      })

   21  const CLAUDE_EXTERNAL_DIR = ".claude"
   22  const AGENTS_EXTERNAL_DIR = ".agents"
   23  const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
   24  const OPENCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md"
   25  const SKILL_PATTERN = "**/SKILL.md"
   26  
   27  // Built-in skill that ships with opencode. The model's intuition for what an
   28  // opencode.json should look like is often wrong, and opencode hard-fails on
   29  // invalid config, so users hit cryptic startup errors. Loading this skill
   30  // when the model is asked to touch opencode's own config files gives it the
   31  // actual schemas instead of guesses.
   32  const CUSTOMIZE_OPENCODE_SKILL_NAME = "customize-opencode"
   33  const CUSTOMIZE_OPENCODE_SKILL_DESCRIPTION =
   34    "Use ONLY when the user is editing or creating opencode's own configuration: opencode.json, opencode.jsonc, files under .opencode/, or files under ~/.config/opencode/. Also use when creating or fixing opencode agents, subagents, skills, plugins, MCP servers, or permission rules. Do not use for the user's own application code, or for any project that is not configuring opencode itself."
   35  const CUSTOMIZE_OPENCODE_SKILL_BODY = SkillPlugin.CustomizeOpencodeContent
   36  
   37  export const Info = Schema.Struct({
   38    name: Schema.String,
   39    description: Schema.optional(Schema.String),
   40    location: Schema.String,
   41    content: Schema.String,
   42  })
   43  export type Info = Schema.Schema.Type<typeof Info>

    4  /**
    5   * Build the `permission` ruleset for a subagent's session when it's spawned
    6   * via the task tool. Combines:
    7   *
    8   * 1. The parent session's deny rules and external_directory rules.
    9   *    Parent agent restrictions only govern that agent; the subagent's own
   10   *    permissions determine its capabilities.
   11   * 2. Default `todowrite` and `task` denies if the subagent's own ruleset
   12   *    doesn't already permit them.
   13   */
   14  export function deriveSubagentSessionPermission(input: {
   15    parentSessionPermission: PermissionV1.Ruleset
   16    subagent: Agent.Info
   17  }): PermissionV1.Ruleset {
   18    const canTask = input.subagent.permission.some((rule) => rule.permission === "task")
   19    const canTodo = input.subagent.permission.some((rule) => rule.permission === "todowrite")
   20    return [
   21      ...input.parentSessionPermission.filter(
   22        (rule) => rule.permission === "external_directory" || rule.action === "deny",
   23      ),
   24      ...(canTodo ? [] : [{ permission: "todowrite" as const, pattern: "*" as const, action: "deny" as const }]),
   25      ...(canTask ? [] : [{ permission: "task" as const, pattern: "*" as const, action: "deny" as const }]),
   26    ]

   24  const id = "task"
   25  const BACKGROUND_DESCRIPTION = [
   26    "Background mode: background=true launches the subagent asynchronously and returns immediately.",
   27    "Foreground is the default; use it when you need the result before continuing.",
   28    "Use background only for independent work that can run while you continue elsewhere.",
   29    "You will be notified automatically when it finishes.",
   30  ].join(" ")
   31  const BACKGROUND_STARTED = [
   32    "The task is working in the background. You will be notified automatically when it finishes.",
   33    "DO NOT sleep, poll for progress, ask the task for status, or duplicate this task's work — avoid working with the same files or topics it is using.",
   34    "Work on non-overlapping tasks, or briefly tell the user what you launched and end your response.",
   35  ].join("\n")
   36  const BACKGROUND_UPDATED = [
   37    "Additional context sent to the running background task.",
   38    "The task is still working in the background. You will be notified automatically when it finishes.",
   39    "DO NOT sleep, poll for progress, ask the task for status, or duplicate this task's work — avoid working with the same files or topics it is using.",
   40    "Work on non-overlapping tasks, or briefly tell the user what you sent and end your response.",
   41  ].join("\n")
   42  
   43  const BaseParameterFields = {
   44    description: Schema.String.annotate({ description: "A short (3-5 words) description of the task" }),
   45    prompt: Schema.String.annotate({ description: "The task for the agent to perform" }),
   46    subagent_type: Schema.String.annotate({ description: "The type of specialized agent to use for this task" }),
   47    task_id: Schema.optional(Schema.String).annotate({
   48      description:
      … 3 lines omitted; exact range 24–62 …
   52  }
   53  
   54  const BaseParameters = Schema.Struct(BaseParameterFields)
   55  
   56  export const Parameters = Schema.Struct({
   57    ...BaseParameterFields,
   58    background: Schema.optional(Schema.Boolean).annotate({
   59      description:
   60        "Run the agent in the background. You will be notified when it completes. DO NOT sleep, poll, or proactively check on its progress",
   61    }),
   62  })

  120  export function toRow(info: Info) {
  121    return {
  122      id: info.id,
  123      project_id: info.projectID,
  124      workspace_id: info.workspaceID,
  125      parent_id: info.parentID,
  126      slug: info.slug,
  127      directory: info.directory,
  128      path: info.path,
  129      title: info.title,
  130      agent: info.agent,
  131      model: info.model,
  132      version: info.version,
  133      share_url: info.share?.url,
  134      summary_additions: info.summary?.additions,
  135      summary_deletions: info.summary?.deletions,
  136      summary_files: info.summary?.files,
  137      summary_diffs: info.summary?.diffs,
  138      metadata: info.metadata,
  139      cost: info.cost ?? 0,
  140      tokens_input: (info.tokens ?? EmptyTokens).input,
  141      tokens_output: (info.tokens ?? EmptyTokens).output,
  142      tokens_reasoning: (info.tokens ?? EmptyTokens).reasoning,
  143      tokens_cache_read: (info.tokens ?? EmptyTokens).cache.read,
  144      tokens_cache_write: (info.tokens ?? EmptyTokens).cache.write,
      … 3 lines omitted; exact range 120–158 …
  148            partID: info.revert.partID,
  149            snapshot: info.revert.snapshot,
  150            diff: info.revert.diff,
  151          }
  152        : null,
  153      permission: info.permission,
  154      time_created: info.time.created,
  155      time_updated: info.time.updated,
  156      time_compacting: info.time.compacting,
  157      time_archived: info.time.archived,
  158    }

   98      const create = Effect.fn("SessionProcessor.create")(function* (input: Input) {
   99        // Pre-capture snapshot before the LLM stream starts. The AI SDK
  100        // may execute tools internally before emitting start-step events,
  101        // so capturing inside the event handler can be too late.
  102        const initialSnapshot = yield* snapshot.track()
  103        const ctx: ProcessorContext = {
  104          assistantMessage: input.assistantMessage,
  105          sessionID: input.sessionID,
  106          model: input.model,
  107          toolcalls: {},
  108          shouldBreak: false,
  109          snapshot: initialSnapshot,
  110          blocked: false,
  111          needsCompaction: false,
  112          currentText: undefined,
  113          reasoningMap: {},
  114        }

   23  const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
   24  
   25  export type Api = {
   26    create: string
   27    sync: (shareID: string) => string
   28    remove: (shareID: string) => string
   29    data: (shareID: string) => string
   30  }
   31  
   32  export type Req = {
   33    headers: Record<string, string>
   34    api: Api
   35    baseUrl: string
   36  }
   37  
   38  const ShareSchema = Schema.Struct({
   39    id: Schema.String,
   40    url: Schema.String,
   41    secret: Schema.String,
   42  })
   43  export type Share = typeof ShareSchema.Type
   44  
   45  type State = {
   46    queue: Map<SessionID, Map<string, Data>>
   47    scope: Scope.Closeable
      … 14 lines omitted; exact range 23–72 …
   62        data: SDK.Part
   63      }
   64    | {
   65        type: "session_diff"
   66        data: SDK.SnapshotFileDiff[]
   67      }
   68    | {
   69        type: "model"
   70        data: SDK.Model[]
   71      }
   72  

  920        }
  921      }),
  922    )
  923  
  924    itCompaction.instance(
  925      "persists tail_start_id for retained recent turns",
  926      Effect.gen(function* () {
  927        const ssn = yield* SessionNs.Service
  928        const session = yield* ssn.create({})
  929        yield* createUserMessage(session.id, "first")
  930        const keep = yield* createUserMessage(session.id, "second")
  931        yield* createUserMessage(session.id, "third")
  932        yield* createSummaryCompaction(session.id)
  933  
  934        const msgs = yield* ssn.messages({ sessionID: session.id })
  935        const parent = msgs.at(-1)?.info.id
  936        expect(parent).toBeTruthy()
  937        yield* SessionCompaction.use.process({
  938          parentID: parent!,
  939          messages: msgs,
  940          sessionID: session.id,
  941          auto: false,
  942        })
  943  
  944        const part = yield* readCompactionPart(session.id)
      … 90 lines omitted; exact range 920–1045 …
 1035        }).pipe(withCompaction({ llm: stub.llmLayer, config: cfg({ tail_turns: 1, preserve_recent_tokens: 100 }) }))
 1036      },
 1037      { git: true },
 1038    )
 1039  
 1040    itCompaction.instance(
 1041      "retains a split turn suffix when a later message fits the preserve token budget",
 1042      () => {
 1043        const stub = llm()
 1044        let captured = ""
 1045        stub.push(reply("summary", (input) => (captured = JSON.stringify(input.messages))))