import path from "path"

import { exec } from "child_process"

import * as prompts from "@clack/prompts"

import { map, pipe, sortBy, values } from "remeda"

import { Octokit } from "@octokit/rest"

import { graphql } from "@octokit/graphql"

import * as core from "@actions/core"

import * as github from "@actions/github"

import type { Context } from "@actions/github/lib/context"

import type {

IssueCommentEvent,

IssuesEvent,

PullRequestReviewCommentEvent,

WorkflowDispatchEvent,

WorkflowRunEvent,

PullRequestEvent,

} from "@octokit/webhooks-types"

import { UI } from "../ui"

import { cmd } from "./cmd"

import { ModelsDev } from "../../provider/models"

import { Instance } from "@/project/instance"

import { bootstrap } from "../bootstrap"

import { Session } from "../../session"

import { Identifier } from "../../id/id"

import { Provider } from "../../provider/provider"

import { Bus } from "../../bus"

import { MessageV2 } from "../../session/message-v2"

import { SessionPrompt } from "@/session/prompt"

import { $ } from "bun"

type GitHubAuthor = {

login: string

name?: string

}

type GitHubComment = {

id: string

databaseId: string

body: string

author: GitHubAuthor

createdAt: string

}

type GitHubReviewComment = GitHubComment & {

path: string

line: number | null

}

type GitHubCommit = {

oid: string

message: string

author: {

name: string

email: string

}

}

type GitHubFile = {

path: string

additions: number

deletions: number

changeType: string

}

type GitHubReview = {

id: string

databaseId: string

author: GitHubAuthor

body: string

state: string

submittedAt: string

comments: {

nodes: GitHubReviewComment[]

}

}

type GitHubPullRequest = {

title: string

body: string

author: GitHubAuthor

baseRefName: string

headRefName: string

headRefOid: string

createdAt: string

additions: number

deletions: number

state: string

baseRepository: {

nameWithOwner: string

}

headRepository: {

nameWithOwner: string

}

commits: {

totalCount: number

nodes: Array<{

commit: GitHubCommit

}>

}

files: {

nodes: GitHubFile[]

}

comments: {

nodes: GitHubComment[]

}

reviews: {

nodes: GitHubReview[]

}

}

type GitHubIssue = {

title: string

body: string

author: GitHubAuthor

createdAt: string

state: string

comments: {

nodes: GitHubComment[]

}

}

type PullRequestQueryResponse = {

repository: {

pullRequest: GitHubPullRequest

}

}

type IssueQueryResponse = {

repository: {

issue: GitHubIssue

}

}

const AGENT_USERNAME = "opencode-agent[bot]"

const AGENT_REACTION = "eyes"

const WORKFLOW_FILE = ".github/workflows/opencode.yml"

// Event categories for routing

// USER_EVENTS: triggered by user actions, have actor/issueId, support reactions/comments

// REPO_EVENTS: triggered by automation, no actor/issueId, output to logs/PR only

const USER_EVENTS = ["issue_comment", "pull_request_review_comment", "issues", "pull_request"] as const

const REPO_EVENTS = ["schedule", "workflow_dispatch"] as const

const SUPPORTED_EVENTS = [...USER_EVENTS, ...REPO_EVENTS] as const

type UserEvent = (typeof USER_EVENTS)[number]

type RepoEvent = (typeof REPO_EVENTS)[number]

// Parses GitHub remote URLs in various formats:

// - https://github.com/owner/repo.git

// - https://github.com/owner/repo

// - git@github.com:owner/repo.git

// - git@github.com:owner/repo

// - ssh://git@github.com/owner/repo.git

// - ssh://git@github.com/owner/repo

export function parseGitHubRemote(url: string): { owner: string; repo: string } | null {

const match = url.match(/^(?:(?:https?|ssh):\/\/)?(?:git@)?github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?$/)

if (!match) return null

return { owner: match[1], repo: match[2] }

}

/**

* Extracts displayable text from assistant response parts.

* Returns null for tool-only or reasoning-only responses (signals summary needed).

* Throws for truly unusable responses (empty, step-start only, etc.).

*/

export function extractResponseText(parts: MessageV2.Part[]): string | null {

// Priority 1: Look for text parts

const textPart = parts.findLast((p) => p.type === "text")

if (textPart) return textPart.text

// Priority 2: Reasoning-only - return null to signal summary needed

const reasoningPart = parts.findLast((p) => p.type === "reasoning")

if (reasoningPart) return null

// Priority 3: Tool-only - return null to signal summary needed

const toolParts = parts.filter((p) => p.type === "tool" && p.state.status === "completed")

if (toolParts.length > 0) return null

// No usable parts - throw with debug info

const partTypes = parts.map((p) => p.type).join(", ") || "none"

throw new Error(`Failed to parse response. Part types found: [${partTypes}]`)

}

export const GithubCommand = cmd({

command: "github",

describe: "manage GitHub agent",

builder: (yargs) => yargs.command(GithubInstallCommand).command(GithubRunCommand).demandCommand(),

async handler() {},

})

export const GithubInstallCommand = cmd({

command: "install",

describe: "install the GitHub agent",

async handler() {

await Instance.provide({

directory: process.cwd(),

async fn() {

{

UI.empty()

prompts.intro("Install GitHub agent")

const app = await getAppInfo()

await installGitHubApp()

const providers = await ModelsDev.get().then((p) => {

// TODO: add guide for copilot, for now just hide it

delete p["github-copilot"]

return p

})

const provider = await promptProvider()

const model = await promptModel()

//const key = await promptKey()

await addWorkflowFiles()

printNextSteps()

function printNextSteps() {

let step2

if (provider === "amazon-bedrock") {

step2 =

"Configure OIDC in AWS - https://docs.github.com/en/actions/how-tos/security-for-github-actions/security-hardening-your-deployments/configuring-openid-connect-in-amazon-web-services"

} else {

step2 = [

` 2. Add the following secrets in org or repo (${app.owner}/${app.repo}) settings`,

"",

...providers[provider].env.map((e) => ` - ${e}`),

].join("\n")

}

prompts.outro(

[

"Next steps:",

"",

` 1. Commit the \`${WORKFLOW_FILE}\` file and push`,

step2,

"",

" 3. Go to a GitHub issue and comment `/oc summarize` to see the agent in action",

"",

" Learn more about the GitHub agent - https://opencode.ai/docs/github/#usage-examples",

].join("\n"),

)

}

async function getAppInfo() {

const project = Instance.project

if (project.vcs !== "git") {

prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)

throw new UI.CancelledError()

}

// Get repo info

const info = (await $`git remote get-url origin`.quiet().nothrow().text()).trim()

const parsed = parseGitHubRemote(info)

if (!parsed) {

prompts.log.error(`Could not find git repository. Please run this command from a git repository.`)

throw new UI.CancelledError()

}

return { owner: parsed.owner, repo: parsed.repo, root: Instance.worktree }

}

async function promptProvider() {

const priority: Record<string, number> = {

opencode: 0,

anthropic: 1,

openai: 2,

google: 3,

}

let provider = await prompts.select({

message: "Select provider",

maxItems: 8,

options: pipe(

providers,

values(),

sortBy(

(x) => priority[x.id] ?? 99,

(x) => x.name ?? x.id,

),

map((x) => ({

label: x.name,

value: x.id,

hint: priority[x.id] === 0 ? "recommended" : undefined,

})),

),

})

if (prompts.isCancel(provider)) throw new UI.CancelledError()

return provider

}

async function promptModel() {

const providerData = providers[provider]!

const model = await prompts.select({

message: "Select model",

maxItems: 8,

options: pipe(

providerData.models,

values(),

sortBy((x) => x.name ?? x.id),

map((x) => ({

label: x.name ?? x.id,

value: x.id,

})),

),

})

if (prompts.isCancel(model)) throw new UI.CancelledError()

return model

}

async function installGitHubApp() {

const s = prompts.spinner()

s.start("Installing GitHub app")

// Get installation

const installation = await getInstallation()

if (installation) return s.stop("GitHub app already installed")

// Open browser

const url = "https://github.com/apps/opencode-agent"

const command =

process.platform === "darwin"

? `open "${url}"`

: process.platform === "win32"

? `start "" "${url}"`

: `xdg-open "${url}"`

exec(command, (error) => {

if (error) {

prompts.log.warn(`Could not open browser. Please visit: ${url}`)

}

})

// Wait for installation

s.message("Waiting for GitHub app to be installed")

const MAX_RETRIES = 120

let retries = 0

do {

const installation = await getInstallation()

if (installation) break

if (retries > MAX_RETRIES) {

s.stop(

`Failed to detect GitHub app installation. Make sure to install the app for the \`${app.owner}/${app.repo}\` repository.`,

)

throw new UI.CancelledError()

}

retries++

await Bun.sleep(1000)

} while (true)

s.stop("Installed GitHub app")

async function getInstallation() {

return await fetch(

`https://api.opencode.ai/get_github_app_installation?owner=${app.owner}&repo=${app.repo}`,

)

.then((res) => res.json())

.then((data) => data.installation)

}

}

async function addWorkflowFiles() {

const envStr =

provider === "amazon-bedrock"

? ""

: `\n env:${providers[provider].env.map((e) => `\n ${e}: \${{ secrets.${e} }}`).join("")}`

await Bun.write(

path.join(app.root, WORKFLOW_FILE),

`name: opencode

on:

issue_comment:

types: [created]

pull_request_review_comment:

types: [created]

jobs:

opencode:

if: |

contains(github.event.comment.body, ' /oc') ||

startsWith(github.event.comment.body, '/oc') ||

contains(github.event.comment.body, ' /opencode') ||

startsWith(github.event.comment.body, '/opencode')

runs-on: ubuntu-latest

permissions:

id-token: write

contents: read

pull-requests: read

issues: read

steps:

- name: Checkout repository

uses: actions/checkout@v6

with:

persist-credentials: false

- name: Run opencode

uses: anomalyco/opencode/github@latest${envStr}

with:

model: ${provider}/${model}`,

)

prompts.log.success(`Added workflow file: "${WORKFLOW_FILE}"`)

}

}

},

})

},

})

export const GithubRunCommand = cmd({

command: "run",

describe: "run the GitHub agent",

builder: (yargs) =>

yargs

.option("event", {

type: "string",

describe: "GitHub mock event to run the agent for",

})

.option("token", {

type: "string",

describe: "GitHub personal access token (github_pat_********)",

}),

async handler(args) {

await bootstrap(process.cwd(), async () => {

const isMock = args.token || args.event

const context = isMock ? (JSON.parse(args.event!) as Context) : github.context

if (!SUPPORTED_EVENTS.includes(context.eventName as (typeof SUPPORTED_EVENTS)[number])) {

core.setFailed(`Unsupported event type: ${context.eventName}`)

process.exit(1)

}

// Determine event category for routing

// USER_EVENTS: have actor, issueId, support reactions/comments

// REPO_EVENTS: no actor/issueId, output to logs/PR only

const isUserEvent = USER_EVENTS.includes(context.eventName as UserEvent)

const isRepoEvent = REPO_EVENTS.includes(context.eventName as RepoEvent)

const isCommentEvent = ["issue_comment", "pull_request_review_comment"].includes(context.eventName)

const isIssuesEvent = context.eventName === "issues"

const isScheduleEvent = context.eventName === "schedule"

const isWorkflowDispatchEvent = context.eventName === "workflow_dispatch"

const { providerID, modelID } = normalizeModel()

const runId = normalizeRunId()

const share = normalizeShare()

const oidcBaseUrl = normalizeOidcBaseUrl()

const { owner, repo } = context.repo

// For repo events (schedule, workflow_dispatch), payload has no issue/comment data

const payload = context.payload as

| IssueCommentEvent

| IssuesEvent

| PullRequestReviewCommentEvent

| WorkflowDispatchEvent

| WorkflowRunEvent

| PullRequestEvent

const issueEvent = isIssueCommentEvent(payload) ? payload : undefined

// workflow_dispatch has an actor (the user who triggered it), schedule does not

const actor = isScheduleEvent ? undefined : context.actor

const issueId = isRepoEvent

? undefined

: context.eventName === "issue_comment" || context.eventName === "issues"

? (payload as IssueCommentEvent | IssuesEvent).issue.number

: (payload as PullRequestEvent | PullRequestReviewCommentEvent).pull_request.number

const runUrl = `/${owner}/${repo}/actions/runs/${runId}`

const shareBaseUrl = isMock ? "https://dev.opencode.ai" : "https://opencode.ai"

let appToken: string

let octoRest: Octokit

let octoGraph: typeof graphql

let gitConfig: string

let session: { id: string; title: string; version: string }

let shareId: string | undefined

let exitCode = 0

type PromptFiles = Awaited<ReturnType<typeof getUserPrompt>>["promptFiles"]

const triggerCommentId = isCommentEvent

? (payload as IssueCommentEvent | PullRequestReviewCommentEvent).comment.id

: undefined

const useGithubToken = normalizeUseGithubToken()

const commentType = isCommentEvent

? context.eventName === "pull_request_review_comment"

? "pr_review"

: "issue"

: undefined

try {

if (useGithubToken) {

const githubToken = process.env["GITHUB_TOKEN"]

if (!githubToken) {

throw new Error(

"GITHUB_TOKEN environment variable is not set. When using use_github_token, you must provide GITHUB_TOKEN.",

)

}

appToken = githubToken

} else {

const actionToken = isMock ? args.token! : await getOidcToken()

appToken = await exchangeForAppToken(actionToken)

}

octoRest = new Octokit({ auth: appToken })

octoGraph = graphql.defaults({

headers: { authorization: `token ${appToken}` },

})

const { userPrompt, promptFiles } = await getUserPrompt()

if (!useGithubToken) {

await configureGit(appToken)

}

// Skip permission check and reactions for repo events (no actor to check, no issue to react to)

if (isUserEvent) {

await assertPermissions()

await addReaction(commentType)

}

// Setup opencode session

const repoData = await fetchRepo()

session = await Session.create({

permission: [

{

permission: "question",

action: "deny",

pattern: "*",

},

],

})

subscribeSessionEvents()

shareId = await (async () => {

if (share === false) return

if (!share && repoData.data.private) return

await Session.share(session.id)

return session.id.slice(-8)

})()

console.log("opencode session", session.id)

// Handle event types:

// REPO_EVENTS (schedule, workflow_dispatch): no issue/PR context, output to logs/PR only

// USER_EVENTS on PR (pull_request, pull_request_review_comment, issue_comment on PR): work on PR branch

// USER_EVENTS on Issue (issue_comment on issue, issues): create new branch, may create PR

if (isRepoEvent) {

// Repo event - no issue/PR context, output goes to logs

if (isWorkflowDispatchEvent && actor) {

console.log(`Triggered by: ${actor}`)

}

const branchPrefix = isWorkflowDispatchEvent ? "dispatch" : "schedule"

const branch = await checkoutNewBranch(branchPrefix)

const head = (await $`git rev-parse HEAD`).stdout.toString().trim()

const response = await chat(userPrompt, promptFiles)

const { dirty, uncommittedChanges } = await branchIsDirty(head)

if (dirty) {

const summary = await summarize(response)

// workflow_dispatch has an actor for co-author attribution, schedule does not

await pushToNewBranch(summary, branch, uncommittedChanges, isScheduleEvent)

const triggerType = isWorkflowDispatchEvent ? "workflow_dispatch" : "scheduled workflow"

const pr = await createPR(

repoData.data.default_branch,

branch,

summary,

`${response}\n\nTriggered by ${triggerType}${footer({ image: true })}`,

)

console.log(`Created PR #${pr}`)

} else {

console.log("Response:", response)

}

} else if (

["pull_request", "pull_request_review_comment"].includes(context.eventName) ||

issueEvent?.issue.pull_request

) {

const prData = await fetchPR()

// Local PR

if (prData.headRepository.nameWithOwner === prData.baseRepository.nameWithOwner) {

await checkoutLocalBranch(prData)

const head = (await $`git rev-parse HEAD`).stdout.toString().trim()

const dataPrompt = buildPromptDataForPR(prData)

const response = await chat(`${userPrompt}\n\n${dataPrompt}`, promptFiles)

const { dirty, uncommittedChanges } = await branchIsDirty(head)

if (dirty) {

const summary = await summarize(response)

await pushToLocalBranch(summary, uncommittedChanges)

}

const hasShared = prData.comments.nodes.some((c) => c.body.includes(`${shareBaseUrl}/s/${shareId}`))

await createComment(`${response}${footer({ image: !hasShared })}`)

await removeReaction(commentType)

}

// Fork PR

else {

await checkoutForkBranch(prData)

const head = (await $`git rev-parse HEAD`).stdout.toString().trim()

const dataPrompt = buildPromptDataForPR(prData)

const response = await chat(`${userPrompt}\n\n${dataPrompt}`, promptFiles)

const { dirty, uncommittedChanges } = await branchIsDirty(head)

if (dirty) {

const summary = await summarize(response)

await pushToForkBranch(summary, prData, uncommittedChanges)

}

const hasShared = prData.comments.nodes.some((c) => c.body.includes(`${shareBaseUrl}/s/${shareId}`))

await createComment(`${response}${footer({ image: !hasShared })}`)

await removeReaction(commentType)

}

}

// Issue

else {

const branch = await checkoutNewBranch("issue")

const head = (await $`git rev-parse HEAD`).stdout.toString().trim()

const issueData = await fetchIssue()

const dataPrompt = buildPromptDataForIssue(issueData)

const response = await chat(`${userPrompt}\n\n${dataPrompt}`, promptFiles)

const { dirty, uncommittedChanges } = await branchIsDirty(head)

if (dirty) {

const summary = await summarize(response)

await pushToNewBranch(summary, branch, uncommittedChanges, false)

const pr = await createPR(

repoData.data.default_branch,

branch,

summary,

`${response}\n\nCloses #${issueId}${footer({ image: true })}`,

)

await createComment(`Created PR #${pr}${footer({ image: true })}`)

await removeReaction(commentType)

} else {

await createComment(`${response}${footer({ image: true })}`)

await removeReaction(commentType)

}

}

} catch (e: any) {

exitCode = 1

console.error(e instanceof Error ? e.message : String(e))

let msg = e

if (e instanceof $.ShellError) {

msg = e.stderr.toString()

} else if (e instanceof Error) {

msg = e.message

}

if (isUserEvent) {

await createComment(`${msg}${footer()}`)

await removeReaction(commentType)

}

core.setFailed(msg)

// Also output the clean error message for the action to capture

//core.setOutput("prepare_error", e.message);

} finally {

if (!useGithubToken) {

await restoreGitConfig()

await revokeAppToken()

}

}

process.exit(exitCode)

function normalizeModel() {

const value = process.env["MODEL"]

if (!value) throw new Error(`Environment variable "MODEL" is not set`)

const { providerID, modelID } = Provider.parseModel(value)

if (!providerID.length || !modelID.length)

throw new Error(`Invalid model ${value}. Model must be in the format "provider/model".`)

return { providerID, modelID }

}

function normalizeRunId() {

const value = process.env["GITHUB_RUN_ID"]

if (!value) throw new Error(`Environment variable "GITHUB_RUN_ID" is not set`)

return value

}

function normalizeShare() {

const value = process.env["SHARE"]

if (!value) return undefined

if (value === "true") return true

if (value === "false") return false

throw new Error(`Invalid share value: ${value}. Share must be a boolean.`)

}

function normalizeUseGithubToken() {

const value = process.env["USE_GITHUB_TOKEN"]

if (!value) return false

if (value === "true") return true

if (value === "false") return false

throw new Error(`Invalid use_github_token value: ${value}. Must be a boolean.`)

}

function normalizeOidcBaseUrl(): string {

const value = process.env["OIDC_BASE_URL"]

if (!value) return "https://api.opencode.ai"

return value.replace(/\/+$/, "")

}

function isIssueCommentEvent(

event:

| IssueCommentEvent

| IssuesEvent

| PullRequestReviewCommentEvent

| WorkflowDispatchEvent

| WorkflowRunEvent

| PullRequestEvent,

): event is IssueCommentEvent {

return "issue" in event && "comment" in event

}

function getReviewCommentContext() {

if (context.eventName !== "pull_request_review_comment") {

return null

}

const reviewPayload = payload as PullRequestReviewCommentEvent

return {

file: reviewPayload.comment.path,

diffHunk: reviewPayload.comment.diff_hunk,

line: reviewPayload.comment.line,

originalLine: reviewPayload.comment.original_line,

position: reviewPayload.comment.position,

commitId: reviewPayload.comment.commit_id,

originalCommitId: reviewPayload.comment.original_commit_id,

}

}

async function getUserPrompt() {

const customPrompt = process.env["PROMPT"]

// For repo events and issues events, PROMPT is required since there's no comment to extract from

if (isRepoEvent || isIssuesEvent) {

if (!customPrompt) {

const eventType = isRepoEvent ? "scheduled and workflow_dispatch" : "issues"

throw new Error(`PROMPT input is required for ${eventType} events`)

}

return { userPrompt: customPrompt, promptFiles: [] }

}

if (customPrompt) {

return { userPrompt: customPrompt, promptFiles: [] }

}

const reviewContext = getReviewCommentContext()

const mentions = (process.env["MENTIONS"] || "/opencode,/oc")

.split(",")

.map((m) => m.trim().toLowerCase())

.filter(Boolean)

let prompt = (() => {

if (!isCommentEvent) {

return "Review this pull request"

}

const body = (payload as IssueCommentEvent | PullRequestReviewCommentEvent).comment.body.trim()

const bodyLower = body.toLowerCase()

if (mentions.some((m) => bodyLower === m)) {

if (reviewContext) {

return `Review this code change and suggest improvements for the commented lines:\n\nFile: ${reviewContext.file}\nLines: ${reviewContext.line}\n\n${reviewContext.diffHunk}`

}

return "Summarize this thread"

}

if (mentions.some((m) => bodyLower.includes(m))) {

if (reviewContext) {

return `${body}\n\nContext: You are reviewing a comment on file "${reviewContext.file}" at line ${reviewContext.line}.\n\nDiff context:\n${reviewContext.diffHunk}`

}

return body

}

throw new Error(`Comments must mention ${mentions.map((m) => "`" + m + "`").join(" or ")}`)

})()

// Handle images

const imgData: {

filename: string

mime: string

content: string

start: number

end: number

replacement: string

}[] = []

// Search for files

// ie. <img alt="Image" src="https://github.com/user-attachments/assets/xxxx" />

// ie. [api.json](https://github.com/user-attachments/files/21433810/api.json)

// ie. 

const mdMatches = prompt.matchAll(/!?\[.*?\]\((https:\/\/github\.com\/user-attachments\/[^)]+)\)/gi)

const tagMatches = prompt.matchAll(/<img .*?src="(https:\/\/github\.com\/user-attachments\/[^"]+)" \/>/gi)

const matches = [...mdMatches, ...tagMatches].sort((a, b) => a.index - b.index)

console.log("Images", JSON.stringify(matches, null, 2))

let offset = 0

for (const m of matches) {

const tag = m[0]

const url = m[1]

const start = m.index

const filename = path.basename(url)

// Download image

const res = await fetch(url, {

headers: {

Authorization: `Bearer ${appToken}`,

Accept: "application/vnd.github.v3+json",

},

})

if (!res.ok) {

console.error(`Failed to download image: ${url}`)

continue

}

// Replace img tag with file path, ie. @image.png

const replacement = `@${filename}`

prompt = prompt.slice(0, start + offset) + replacement + prompt.slice(start + offset + tag.length)

offset += replacement.length - tag.length

const contentType = res.headers.get("content-type")

imgData.push({

filename,

mime: contentType?.startsWith("image/") ? contentType : "text/plain",

content: Buffer.from(await res.arrayBuffer()).toString("base64"),

start,

end: start + replacement.length,

replacement,

})

}

return { userPrompt: prompt, promptFiles: imgData }

}

function subscribeSessionEvents() {

const TOOL: Record<string, [string, string]> = {

todowrite: ["Todo", UI.Style.TEXT_WARNING_BOLD],

todoread: ["Todo", UI.Style.TEXT_WARNING_BOLD],

bash: ["Bash", UI.Style.TEXT_DANGER_BOLD],

edit: ["Edit", UI.Style.TEXT_SUCCESS_BOLD],

glob: ["Glob", UI.Style.TEXT_INFO_BOLD],

grep: ["Grep", UI.Style.TEXT_INFO_BOLD],

list: ["List", UI.Style.TEXT_INFO_BOLD],

read: ["Read", UI.Style.TEXT_HIGHLIGHT_BOLD],

write: ["Write", UI.Style.TEXT_SUCCESS_BOLD],

websearch: ["Search", UI.Style.TEXT_DIM_BOLD],

}

function printEvent(color: string, type: string, title: string) {

UI.println(

color + `|`,

UI.Style.TEXT_NORMAL + UI.Style.TEXT_DIM + ` ${type.padEnd(7, " ")}`,

"",

UI.Style.TEXT_NORMAL + title,

)

}

let text = ""

Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {

if (evt.properties.part.sessionID !== session.id) return

//if (evt.properties.part.messageID === messageID) return

const part = evt.properties.part

if (part.type === "tool" && part.state.status === "completed") {

const [tool, color] = TOOL[part.tool] ?? [part.tool, UI.Style.TEXT_INFO_BOLD]

const title =

part.state.title || Object.keys(part.state.input).length > 0

? JSON.stringify(part.state.input)

: "Unknown"

console.log()

printEvent(color, tool, title)

}

if (part.type === "text") {

text = part.text

if (part.time?.end) {

UI.empty()

UI.println(UI.markdown(text))

UI.empty()

text = ""

return

}

}

})

}

async function summarize(response: string) {

try {

return await chat(`Summarize the following in less than 40 characters:\n\n${response}`)

} catch (e) {

const title = issueEvent

? issueEvent.issue.title

: (payload as PullRequestReviewCommentEvent).pull_request.title

return `Fix issue: ${title}`

}

}

async function chat(message: string, files: PromptFiles = []) {

console.log("Sending message to opencode...")

const result = await SessionPrompt.prompt({

sessionID: session.id,

messageID: Identifier.ascending("message"),

model: {

providerID,

modelID,

},

// agent is omitted - server will use default_agent from config or fall back to "build"

parts: [

{

id: Identifier.ascending("part"),

type: "text",

text: message,

},

...files.flatMap((f) => [

{

id: Identifier.ascending("part"),

type: "file" as const,

mime: f.mime,

url: `data:${f.mime};base64,${f.content}`,

filename: f.filename,

source: {

type: "file" as const,

text: {

value: f.replacement,

start: f.start,

end: f.end,

},

path: f.filename,

},

},

]),

],

})

// result should always be assistant just satisfying type checker

if (result.info.role === "assistant" && result.info.error) {

console.error("Agent error:", result.info.error)

throw new Error(

`${result.info.error.name}: ${"message" in result.info.error ? result.info.error.message : ""}`,

)

}

const text = extractResponseText(result.parts)

if (text) return text

// No text part (tool-only or reasoning-only) - ask agent to summarize

console.log("Requesting summary from agent...")

const summary = await SessionPrompt.prompt({

sessionID: session.id,

messageID: Identifier.ascending("message"),

model: {

providerID,

modelID,

},

tools: { "*": false }, // Disable all tools to force text response

parts: [

{

id: Identifier.ascending("part"),

type: "text",

text: "Summarize the actions (tool calls & reasoning) you did for the user in 1-2 sentences.",

},

],

})

if (summary.info.role === "assistant" && summary.info.error) {

console.error("Summary agent error:", summary.info.error)

throw new Error(

`${summary.info.error.name}: ${"message" in summary.info.error ? summary.info.error.message : ""}`,

)

}

const summaryText = extractResponseText(summary.parts)

if (!summaryText) {

throw new Error("Failed to get summary from agent")

}

return summaryText

}

async function getOidcToken() {

try {

return await core.getIDToken("opencode-github-action")

} catch (error) {

console.error("Failed to get OIDC token:", error instanceof Error ? error.message : error)

throw new Error(

"Could not fetch an OIDC token. Make sure to add `id-token: write` to your workflow permissions.",

)

}

}

async function exchangeForAppToken(token: string) {

const response = token.startsWith("github_pat_")

? await fetch(`${oidcBaseUrl}/exchange_github_app_token_with_pat`, {

method: "POST",

headers: {

Authorization: `Bearer ${token}`,

},

body: JSON.stringify({ owner, repo }),

})

: await fetch(`${oidcBaseUrl}/exchange_github_app_token`, {

method: "POST",

headers: {

Authorization: `Bearer ${token}`,

},

})

if (!response.ok) {

const responseJson = (await response.json()) as { error?: string }

throw new Error(

`App token exchange failed: ${response.status} ${response.statusText} - ${responseJson.error}`,

)

}

const responseJson = (await response.json()) as { token: string }

return responseJson.token

}