const result: Info = {

id: Identifier.descending("session"),

version: Installation.VERSION,

parentID,

title: (parentID ? "Child session - " : "New Session - ") + new Date().toISOString(),

time: {

created: Date.now(),

updated: Date.now(),

},

}

log.info("created", result)

state().sessions.set(result.id, result)

await Storage.writeJSON("session/info/" + result.id, result)

const cfg = await Config.get()

if (!result.parentID && (Flag.OPENCODE_AUTO_SHARE || cfg.share === "auto"))

share(result.id)

.then((share) => {

update(result.id, (draft) => {

draft.share = share

})

})

.catch(() => {

// Silently ignore sharing errors during session creation

})

Bus.publish(Event.Updated, {

info: result,

})

return result

const result = state().sessions.get(id)

if (result) {

return result

}

const read = await Storage.readJSON<Info>("session/info/" + id)

state().sessions.set(id, read)

return read as Info

const cfg = await Config.get()

if (cfg.share === "disabled") {

throw new Error("Sharing is disabled in configuration")

}

const session = await get(id)

if (session.share) return session.share

const share = await Share.create(id)

await update(id, (draft) => {

draft.share = {

url: share.url,

}

})

await Storage.writeJSON<ShareInfo>("session/share/" + id, share)

await Share.sync("session/info/" + id, session)

for (const msg of await messages(id)) {

await Share.sync("session/message/" + id + "/" + msg.info.id, msg.info)

for (const part of msg.parts) {

await Share.sync("session/part/" + id + "/" + msg.info.id + "/" + part.id, part)

}

}

return share

const share = await getShare(id)

if (!share) return

await Storage.remove("session/share/" + id)

await update(id, (draft) => {

draft.share = undefined

})

await Share.remove(id, share.secret)

const { sessions } = state()

const session = await get(id)

if (!session) return

editor(session)

session.time.updated = Date.now()

sessions.set(id, session)

await Storage.writeJSON("session/info/" + id, session)

Bus.publish(Event.Updated, {

info: session,

})

return session

const result = [] as {

info: MessageV2.Info

parts: MessageV2.Part[]

}[]

for (const p of await Storage.list("session/message/" + sessionID)) {

const read = await Storage.readJSON<MessageV2.Info>(p)

result.push({

info: read,

parts: await getParts(sessionID, read.id),

})

}

result.sort((a, b) => (a.info.id > b.info.id ? 1 : -1))

return result

const result = [] as MessageV2.Part[]

for (const item of await Storage.list("session/part/" + sessionID + "/" + messageID)) {

const read = await Storage.readJSON<MessageV2.Part>(item)

result.push(read)

}

result.sort((a, b) => (a.id > b.id ? 1 : -1))

return result

for (const item of await Storage.list("session/info")) {

const sessionID = path.basename(item, ".json")

yield get(sessionID)

}

const result = [] as Session.Info[]

for (const item of await Storage.list("session/info")) {

const sessionID = path.basename(item, ".json")

const session = await get(sessionID)

if (session.parentID !== parentID) continue

result.push(session)

}

return result

const controller = state().pending.get(sessionID)

if (!controller) return false

log.info("aborting", {

sessionID,

})

controller.abort()

state().pending.delete(sessionID)

return true

try {

abort(sessionID)

const session = await get(sessionID)

for (const child of await children(sessionID)) {

await remove(child.id, false)

}

await unshare(sessionID).catch(() => {})

await Storage.remove(`session/info/${sessionID}`).catch(() => {})

await Storage.removeDir(`session/message/${sessionID}/`).catch(() => {})

state().sessions.delete(sessionID)

state().messages.delete(sessionID)

if (emitEvent) {

Bus.publish(Event.Deleted, {

info: session,

})

}

} catch (e) {

log.error(e)

}

await Storage.writeJSON("session/message/" + msg.sessionID + "/" + msg.id, msg)

Bus.publish(MessageV2.Event.Updated, {

info: msg,

})

await Storage.writeJSON(["session", "part", part.sessionID, part.messageID, part.id].join("/"), part)

Bus.publish(MessageV2.Event.PartUpdated, {

part,

})

return part

input: z.infer<typeof ChatInput>,

): Promise<{ info: MessageV2.Assistant; parts: MessageV2.Part[] }> {

const l = log.clone().tag("session", input.sessionID)

l.info("chatting")

const inputMode = input.mode ?? "build"

const userMsg: MessageV2.Info = {

id: input.messageID ?? Identifier.ascending("message"),

role: "user",

sessionID: input.sessionID,

time: {

created: Date.now(),

},

}

const app = App.info()

const userParts = await Promise.all(

input.parts.map(async (part): Promise<MessageV2.Part[]> => {

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

const url = new URL(part.url)

switch (url.protocol) {

case "data:":

if (part.mime === "text/plain") {

return [

{

id: Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "text",

synthetic: true,

text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: part.filename })}`,

},

{

id: Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "text",

synthetic: true,

text: Buffer.from(part.url, "base64url").toString(),

},

{

...part,

id: part.id ?? Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

},

]

}

break

case "file:":

// have to normalize, symbol search returns absolute paths

// Decode the pathname since URL constructor doesn't automatically decode it

const filePath = decodeURIComponent(url.pathname)

if (part.mime === "text/plain") {

let offset: number | undefined = undefined

let limit: number | undefined = undefined

const range = {

start: url.searchParams.get("start"),

end: url.searchParams.get("end"),

}

if (range.start != null) {

const filePath = part.url.split("?")[0]

let start = parseInt(range.start)

let end = range.end ? parseInt(range.end) : undefined

// some LSP servers (eg, gopls) don't give full range in

// workspace/symbol searches, so we'll try to find the

// symbol in the document to get the full range

if (start === end) {

const symbols = await LSP.documentSymbol(filePath)

for (const symbol of symbols) {

let range: LSP.Range | undefined

if ("range" in symbol) {

range = symbol.range

} else if ("location" in symbol) {

range = symbol.location.range

}

if (range?.start?.line && range?.start?.line === start) {

start = range.start.line

end = range?.end?.line ?? start

break

}

}

offset = Math.max(start - 2, 0)

if (end) {

limit = end - offset + 2

}

}

}

const args = { filePath, offset, limit }

const result = await ReadTool.init().then((t) =>

t.execute(args, {

sessionID: input.sessionID,

abort: new AbortController().signal,

messageID: userMsg.id,

metadata: async () => {},

}),

)

return [

{

id: Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "text",

synthetic: true,

text: `Called the Read tool with the following input: ${JSON.stringify(args)}`,

},

{

id: Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "text",

synthetic: true,

text: result.output,

},

{

...part,

id: part.id ?? Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

},

]

}

let file = Bun.file(filePath)

FileTime.read(input.sessionID, filePath)

return [

{

id: Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "text",

text: `Called the Read tool with the following input: {\"filePath\":\"${filePath}\"}`,

synthetic: true,

},

{

id: part.id ?? Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "file",

url: `data:${part.mime};base64,` + Buffer.from(await file.bytes()).toString("base64"),

mime: part.mime,

filename: part.filename!,

source: part.source,

},

]

}

}

return [

{

id: Identifier.ascending("part"),

...part,

messageID: userMsg.id,

sessionID: input.sessionID,

},

]

}),

).then((x) => x.flat())

if (inputMode === "plan")

userParts.push({

id: Identifier.ascending("part"),

messageID: userMsg.id,

sessionID: input.sessionID,

type: "text",

text: PROMPT_PLAN,

synthetic: true,

})

await updateMessage(userMsg)

for (const part of userParts) {

await updatePart(part)

}

if (isLocked(input.sessionID)) {

return new Promise((resolve) => {

const queue = state().queued.get(input.sessionID) ?? []

queue.push({

input: input,

message: userMsg,

parts: userParts,

processed: false,

callback: resolve,

})

state().queued.set(input.sessionID, queue)

})

}

const model = await Provider.getModel(input.providerID, input.modelID)

let msgs = await messages(input.sessionID)

const session = await get(input.sessionID)

if (session.revert) {

const messageID = session.revert.messageID

const [preserve, remove] = splitWhen(msgs, (x) => x.info.id === messageID)

msgs = preserve

for (const msg of remove) {

if (msg.info.id === userMsg.id) continue

await Storage.remove(`session/message/${input.sessionID}/${msg.info.id}`)

await Bus.publish(MessageV2.Event.Removed, { sessionID: input.sessionID, messageID: msg.info.id })

}

const last = preserve.at(-1)

if (session.revert.partID && last) {

const partID = session.revert.partID

const [preserveParts, removeParts] = splitWhen(last.parts, (x) => x.id === partID)

last.parts = preserveParts

for (const part of removeParts) {

await Storage.remove(`session/part/${input.sessionID}/${last.info.id}/${part.id}`)

await Bus.publish(MessageV2.Event.PartRemoved, {

sessionID: input.sessionID,

messageID: last.info.id,

partID: part.id,

})

}

}

await update(input.sessionID, (draft) => {

draft.revert = undefined

})

}

const previous = msgs.filter((x) => x.info.role === "assistant").at(-1)?.info as MessageV2.Assistant

const outputLimit = Math.min(model.info.limit.output, OUTPUT_TOKEN_MAX) || OUTPUT_TOKEN_MAX

// auto summarize if too long

if (previous && previous.tokens) {

const tokens =

previous.tokens.input + previous.tokens.cache.read + previous.tokens.cache.write + previous.tokens.output

if (model.info.limit.context && tokens > Math.max((model.info.limit.context - outputLimit) * 0.9, 0)) {

await summarize({

sessionID: input.sessionID,

providerID: input.providerID,

modelID: input.modelID,

})

return chat(input)

}

}

using abort = lock(input.sessionID)

const lastSummary = msgs.findLast((msg) => msg.info.role === "assistant" && msg.info.summary === true)

if (lastSummary) msgs = msgs.filter((msg) => msg.info.id >= lastSummary.info.id)

if (msgs.length === 1 && !session.parentID) {

const small = (await Provider.getSmallModel(input.providerID)) ?? model

generateText({

maxOutputTokens: small.info.reasoning ? 1024 : 20,

providerOptions: {

[input.providerID]: small.info.options,

},

messages: [

...SystemPrompt.title(input.providerID).map(

(x): ModelMessage => ({

role: "system",

content: x,

}),

),

...MessageV2.toModelMessage([

{

info: {

id: Identifier.ascending("message"),

role: "user",

sessionID: input.sessionID,

time: {

created: Date.now(),

},

},

parts: userParts,

},

]),

],

model: small.language,

})

.then((result) => {

if (result.text)

return Session.update(input.sessionID, (draft) => {

const cleaned = result.text.replace(/<think>[\s\S]*?<\/think>\s*/g, "")

const title = cleaned.length > 100 ? cleaned.substring(0, 97) + "..." : cleaned

draft.title = title.trim()

})

})

.catch(() => {})

}

const mode = await Mode.get(inputMode)

let system = SystemPrompt.header(input.providerID)

system.push(

...(() => {

if (input.system) return [input.system]

if (mode.prompt) return [mode.prompt]

return SystemPrompt.provider(input.modelID)

})(),

)

system.push(...(await SystemPrompt.environment()))

system.push(...(await SystemPrompt.custom()))

// max 2 system prompt messages for caching purposes

const [first, ...rest] = system

system = [first, rest.join("\n")]

const assistantMsg: MessageV2.Info = {

id: Identifier.ascending("message"),

role: "assistant",

system,

mode: inputMode,

path: {

cwd: app.path.cwd,

root: app.path.root,

},

cost: 0,

tokens: {

input: 0,

output: 0,

reasoning: 0,

cache: { read: 0, write: 0 },

},

modelID: input.modelID,

providerID: input.providerID,

time: {

created: Date.now(),

},

sessionID: input.sessionID,

}

await updateMessage(assistantMsg)

const tools: Record<string, AITool> = {}

const processor = createProcessor(assistantMsg, model.info)

const enabledTools = pipe(

mode.tools,

mergeDeep(ToolRegistry.enabled(input.providerID, input.modelID)),

mergeDeep(input.tools ?? {}),

)

for (const item of await ToolRegistry.tools(input.providerID, input.modelID)) {

if (enabledTools[item.id] === false) continue

tools[item.id] = tool({

id: item.id as any,

description: item.description,

inputSchema: item.parameters as ZodSchema,

async execute(args, options) {

await processor.track(options.toolCallId)

const result = await item.execute(args, {

sessionID: input.sessionID,

abort: abort.signal,

messageID: assistantMsg.id,

metadata: async (val) => {

const match = processor.partFromToolCall(options.toolCallId)

if (match && match.state.status === "running") {

await updatePart({

...match,

state: {

title: val.title,

metadata: val.metadata,

status: "running",

input: args,

time: {

start: Date.now(),

},

},

})

}

},

})

return result

},

toModelOutput(result) {

return {

type: "text",

value: result.output,

}

},

})

}

for (const [key, item] of Object.entries(await MCP.tools())) {

if (mode.tools[key] === false) continue

const execute = item.execute

if (!execute) continue

item.execute = async (args, opts) => {