onlycode 1.18.0 → 1.20.0

package/src/acp/directory.ts

@@ -1,210 +0,0 @@
-import { Agent } from "@/agent/agent"
-import { Command } from "@/command"
-import { InstanceRef } from "@/effect/instance-ref"
-import { InstanceStore } from "@/project/instance-store"
-import { ProviderV2 } from "@opencode-ai/core/provider"
-import { ModelV2 } from "@opencode-ai/core/model"
-import { Provider } from "@/provider/provider"
-import { Context, Effect, Layer, SynchronizedRef } from "effect"
-import type * as ACPError from "./error"
-
-export type ModelOption = {
-  readonly providerID: ProviderV2.ID
-  readonly providerName: string
-  readonly modelID: ModelV2.ID
-  readonly modelName: string
-}
-
-export type ModeOption = {
-  readonly id: string
-  readonly name: string
-  readonly description?: string
-}
-
-export type ModelVariants = NonNullable<Provider.Model["variants"]>
-
-export type DefaultModel = {
-  readonly providerID: ProviderV2.ID
-  readonly modelID: ModelV2.ID
-}
-
-export type Snapshot = {
-  readonly directory: string
-  readonly providers: Record<ProviderV2.ID, Provider.Info>
-  readonly modelOptions: readonly ModelOption[]
-  readonly variantsByModel: Readonly<Record<string, ModelVariants>>
-  readonly availableModes: readonly ModeOption[]
-  readonly defaultModeID: string
-  readonly availableCommands: readonly Command.Info[]
-  readonly defaultModel?: DefaultModel
-}
-
-export interface LoaderInterface {
-  readonly load: (directory: string) => Effect.Effect<Snapshot, ACPError.Error>
-}
-
-export interface Interface {
-  readonly get: (directory: string) => Effect.Effect<Snapshot, ACPError.Error>
-  readonly refresh: (directory: string) => Effect.Effect<Snapshot, ACPError.Error>
-  readonly variants: (snapshot: Snapshot, model: DefaultModel) => ModelVariants | undefined
-}
-
-export class Loader extends Context.Service<Loader, LoaderInterface>()("@opencode/ACPDirectoryLoader") {}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/ACPDirectory") {}
-
-export const modelKey = (model: DefaultModel) => `${model.providerID}/${model.modelID}`
-
-export const variants = (snapshot: Snapshot, model: DefaultModel) => snapshot.variantsByModel[modelKey(model)]
-
-export const build = (input: {
-  readonly directory: string
-  readonly providers: Record<ProviderV2.ID, Provider.Info>
-  readonly modes: readonly ModeOption[]
-  readonly defaultModeID: string
-  readonly commands: readonly Command.Info[]
-  readonly defaultModel?: DefaultModel
-}): Snapshot => {
-  const modelOptions = Provider.sort(
-    Object.values(input.providers).flatMap((provider) =>
-      Object.values(provider.models).map((model) => ({
-        id: model.id,
-        providerID: provider.id,
-        providerName: provider.name,
-        modelID: model.id,
-        modelName: model.name,
-      })),
-    ),
-  ).map((model) => ({
-    providerID: model.providerID,
-    providerName: model.providerName,
-    modelID: model.modelID,
-    modelName: model.modelName,
-  }))
-
-  return {
-    directory: input.directory,
-    providers: input.providers,
-    modelOptions,
-    variantsByModel: Object.fromEntries(
-      Object.values(input.providers).flatMap((provider) =>
-        Object.values(provider.models).flatMap((model) =>
-          model.variants ? [[modelKey({ providerID: provider.id, modelID: model.id }), model.variants]] : [],
-        ),
-      ),
-    ),
-    availableModes: input.modes,
-    defaultModeID: input.modes.some((mode) => mode.id === input.defaultModeID)
-      ? input.defaultModeID
-      : (input.modes[0]?.id ?? input.defaultModeID),
-    availableCommands: input.commands,
-    ...(input.defaultModel ? { defaultModel: input.defaultModel } : {}),
-  }
-}
-
-export const loaderLayer = Layer.effect(
-  Loader,
-  Effect.gen(function* () {
-    const store = yield* InstanceStore.Service
-    const provider = yield* Provider.Service
-    const agent = yield* Agent.Service
-    const command = yield* Command.Service
-
-    return Loader.of({
-      load: Effect.fn("ACPDirectoryLoader.load")(function* (directory) {
-        const ctx = yield* store.load({ directory })
-        return yield* Effect.gen(function* () {
-          const providers = yield* provider.list()
-          const [agents, defaultAgent, commands, defaultModel] = yield* Effect.all(
-            [agent.list(), agent.defaultInfo(), command.list(), provider.defaultModel().pipe(Effect.option)],
-            { concurrency: "unbounded" },
-          )
-          return build({
-            directory,
-            providers,
-            modes: agents
-              .filter((item) => item.mode !== "subagent" && item.hidden !== true)
-              .map((item) => ({
-                id: item.name,
-                name: item.name,
-                ...(item.description ? { description: item.description } : {}),
-              })),
-            defaultModeID: defaultAgent.name,
-            commands: commands.toSorted((a, b) => a.name.localeCompare(b.name)),
-            ...(defaultModel._tag === "Some" ? { defaultModel: defaultModel.value } : {}),
-          })
-        }).pipe(Effect.provideService(InstanceRef, ctx))
-      }),
-    })
-  }),
-)
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const loader = yield* Loader
-    const snapshots = yield* SynchronizedRef.make(new Map<string, Effect.Effect<Snapshot, ACPError.Error>>())
-
-    const cached = Effect.fnUntraced(function* (directory: string) {
-      return yield* SynchronizedRef.modifyEffect(
-        snapshots,
-        Effect.fnUntraced(function* (items) {
-          const current = items.get(directory)
-          if (current) return [current, items] as const
-          const next = yield* Effect.cached(
-            loader.load(directory).pipe(
-              Effect.tapError(() =>
-                SynchronizedRef.update(snapshots, (state) => {
-                  const next = new Map(state)
-                  next.delete(directory)
-                  return next
-                }),
-              ),
-            ),
-          )
-          return [next, new Map(items).set(directory, next)] as const
-        }),
-      )
-    })
-
-    const get = Effect.fn("ACPDirectory.get")(function* (directory: string) {
-      return yield* yield* cached(directory)
-    })
-
-    const refresh = Effect.fn("ACPDirectory.refresh")(function* (directory: string) {
-      return yield* SynchronizedRef.modifyEffect(
-        snapshots,
-        Effect.fnUntraced(function* (items) {
-          const next = yield* Effect.cached(
-            loader.load(directory).pipe(
-              Effect.tapError(() =>
-                SynchronizedRef.update(snapshots, (state) => {
-                  const next = new Map(state)
-                  next.delete(directory)
-                  return next
-                }),
-              ),
-            ),
-          )
-          return [next, new Map(items).set(directory, next)] as const
-        }),
-      ).pipe(Effect.flatten)
-    })
-
-    return Service.of({
-      get,
-      refresh,
-      variants,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(loaderLayer),
-  Layer.provide(Provider.defaultLayer),
-  Layer.provide(Agent.defaultLayer),
-  Layer.provide(Command.defaultLayer),
-  Layer.provide(InstanceStore.defaultLayer),
-)
-
-export * as Directory from "./directory"

package/src/acp/error.ts

@@ -1,90 +0,0 @@
-import { RequestError } from "@agentclientprotocol/sdk"
-import { Schema } from "effect"
-
-export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()("ACPSessionNotFoundError", {
-  sessionId: Schema.String,
-}) {}
-
-export class InvalidConfigOptionError extends Schema.TaggedErrorClass<InvalidConfigOptionError>()(
-  "ACPInvalidConfigOptionError",
-  {
-    configId: Schema.String,
-  },
-) {}
-
-export class InvalidModelError extends Schema.TaggedErrorClass<InvalidModelError>()("ACPInvalidModelError", {
-  modelId: Schema.String,
-  providerId: Schema.optional(Schema.String),
-}) {}
-
-export class InvalidEffortError extends Schema.TaggedErrorClass<InvalidEffortError>()("ACPInvalidEffortError", {
-  effort: Schema.String,
-}) {}
-
-export class InvalidModeError extends Schema.TaggedErrorClass<InvalidModeError>()("ACPInvalidModeError", {
-  mode: Schema.String,
-}) {}
-
-export class AuthRequiredError extends Schema.TaggedErrorClass<AuthRequiredError>()("ACPAuthRequiredError", {
-  providerId: Schema.optional(Schema.String),
-}) {}
-
-export class UnknownAuthMethodError extends Schema.TaggedErrorClass<UnknownAuthMethodError>()(
-  "ACPUnknownAuthMethodError",
-  {
-    methodId: Schema.String,
-  },
-) {}
-
-export class UnsupportedOperationError extends Schema.TaggedErrorClass<UnsupportedOperationError>()(
-  "ACPUnsupportedOperationError",
-  {
-    method: Schema.String,
-  },
-) {}
-
-export class ServiceFailureError extends Schema.TaggedErrorClass<ServiceFailureError>()("ACPServiceFailureError", {
-  safeMessage: Schema.String,
-  service: Schema.optional(Schema.String),
-}) {}
-
-export type Error =
-  | SessionNotFoundError
-  | InvalidConfigOptionError
-  | InvalidModelError
-  | InvalidEffortError
-  | InvalidModeError
-  | AuthRequiredError
-  | UnknownAuthMethodError
-  | UnsupportedOperationError
-  | ServiceFailureError
-
-export function toRequestError(error: Error) {
-  switch (error._tag) {
-    case "ACPSessionNotFoundError":
-      return RequestError.invalidParams({ sessionId: error.sessionId }, `session not found: ${error.sessionId}`)
-    case "ACPInvalidConfigOptionError":
-      return RequestError.invalidParams({ configId: error.configId }, `unknown config option: ${error.configId}`)
-    case "ACPInvalidModelError":
-      return RequestError.invalidParams(
-        { providerId: error.providerId, modelId: error.modelId },
-        `model not found: ${error.modelId}`,
-      )
-    case "ACPInvalidEffortError":
-      return RequestError.invalidParams({ effort: error.effort }, `effort not found: ${error.effort}`)
-    case "ACPInvalidModeError":
-      return RequestError.invalidParams({ mode: error.mode }, `mode not found: ${error.mode}`)
-    case "ACPAuthRequiredError":
-      return RequestError.authRequired({ providerId: error.providerId }, "provider authentication required")
-    case "ACPUnknownAuthMethodError":
-      return RequestError.invalidParams({ methodId: error.methodId }, `unknown auth method: ${error.methodId}`)
-    case "ACPUnsupportedOperationError":
-      return RequestError.methodNotFound(error.method)
-    case "ACPServiceFailureError":
-      return RequestError.internalError({ service: error.service }, error.safeMessage)
-  }
-}
-
-export function fromUnknownDefect(_defect: unknown, safeMessage = "Internal service failure") {
-  return new ServiceFailureError({ safeMessage })
-}

package/src/acp/event.ts

@@ -1,342 +0,0 @@
-import type { AgentSideConnection } from "@agentclientprotocol/sdk"
-import type {
-  Event,
-  EventMessagePartDelta,
-  EventMessagePartUpdated,
-  OpencodeClient,
-  Part,
-  SessionMessageResponse,
-  ToolPart,
-} from "@opencode-ai/sdk/v2"
-import { Effect } from "effect"
-import { ACPSession } from "./session"
-import { ACPPermission } from "./permission"
-import { partsToContentChunks, type ReplayPart } from "./content"
-import {
-  duplicateRunningToolUpdate,
-  errorToolUpdate,
-  pendingToolCall,
-  runningToolUpdate,
-  shellOutputSnapshot,
-  completedToolUpdate,
-} from "./tool"
-
-type Connection = Pick<AgentSideConnection, "sessionUpdate"> &
-  Partial<Pick<AgentSideConnection, "requestPermission" | "writeTextFile">>
-type GlobalEventEnvelope = {
-  payload?: Event
-}
-type GlobalEventStream = {
-  stream: AsyncIterable<GlobalEventEnvelope>
-}
-
-export function start(input: { sdk: OpencodeClient; connection: Connection; session: ACPSession.Interface }) {
-  const subscription = new Subscription(input)
-  subscription.start()
-  return subscription
-}
-
-export class Subscription {
-  private readonly abort = new AbortController()
-  private readonly shellSnapshots = new Map<string, string>()
-  private readonly toolStarts = new Set<string>()
-  private readonly permission: ACPPermission.Handler
-  private started = false
-
-  constructor(
-    private readonly input: {
-      sdk: OpencodeClient
-      connection: Connection
-      session: ACPSession.Interface
-    },
-  ) {
-    this.permission = new ACPPermission.Handler(input)
-  }
-
-  start() {
-    if (this.started) return
-    this.started = true
-    this.run().catch(() => {
-      if (this.abort.signal.aborted) return
-    })
-  }
-
-  stop() {
-    this.abort.abort()
-  }
-
-  async handle(event: Event) {
-    switch (event.type) {
-      case "permission.asked":
-        this.permission.handle(event)
-        return
-      case "message.part.updated":
-        return this.handlePartUpdated(event)
-      case "message.part.delta":
-        return this.handlePartDelta(event)
-    }
-  }
-
-  async replayMessage(message: SessionMessageResponse) {
-    if (message.info.role !== "assistant" && message.info.role !== "user") return
-
-    const cwd = message.info.role === "assistant" ? message.info.path?.cwd : undefined
-    for (const part of message.parts) {
-      await this.recordFetchedPart(message.info.sessionID, message, part)
-      if (part.type === "tool") {
-        await this.handleToolPart(message.info.sessionID, part, cwd ?? process.cwd())
-        continue
-      }
-      await this.replayContentPart(message, part)
-    }
-  }
-
-  private async replayContentPart(message: SessionMessageResponse, part: Part) {
-    if (part.type !== "text" && part.type !== "file" && part.type !== "reasoning") return
-
-    const sessionUpdate =
-      part.type === "reasoning"
-        ? "agent_thought_chunk"
-        : message.info.role === "user"
-          ? "user_message_chunk"
-          : "agent_message_chunk"
-
-    for (const chunk of partsToContentChunks([part as ReplayPart])) {
-      await this.input.connection.sessionUpdate({
-        sessionId: message.info.sessionID,
-        update: {
-          sessionUpdate,
-          messageId: message.info.id,
-          ...chunk,
-        },
-      })
-    }
-  }
-
-  private async run() {
-    while (!this.abort.signal.aborted) {
-      const events = (await this.input.sdk.global.event({
-        signal: this.abort.signal,
-      })) as GlobalEventStream
-
-      for await (const event of events.stream) {
-        if (this.abort.signal.aborted) return
-        if (!event.payload) continue
-        await this.handle(event.payload).catch(() => {})
-      }
-      if (!this.abort.signal.aborted) await new Promise((resolve) => setTimeout(resolve, 1000))
-    }
-  }
-
-  private async handlePartUpdated(event: EventMessagePartUpdated) {
-    const part = event.properties.part
-    const sessionId = part.sessionID || event.properties.sessionID
-    const session = await Effect.runPromise(this.input.session.tryGet(sessionId))
-    if (!session) return
-
-    await Effect.runPromise(
-      this.input.session.recordPartMetadata({
-        sessionId: session.id,
-        messageId: part.messageID,
-        partId: part.id,
-        partType: part.type,
-        role: part.type === "reasoning" ? "assistant" : undefined,
-        ignored: part.type === "text" ? part.ignored : undefined,
-        toolCallId: part.type === "tool" ? part.callID : undefined,
-        metadata: "metadata" in part ? part.metadata : undefined,
-      }),
-    )
-    if (part.type === "tool") {
-      await this.handleToolPart(session.id, part, session.cwd)
-    }
-  }
-
-  private async handlePartDelta(event: EventMessagePartDelta) {
-    const props = event.properties
-    const session = await Effect.runPromise(this.input.session.tryGet(props.sessionID))
-    if (!session) return
-
-    const known = await Effect.runPromise(
-      this.input.session.tryGetPartMetadata({
-        sessionId: session.id,
-        messageId: props.messageID,
-        partId: props.partID,
-      }),
-    )
-    const metadata =
-      known?.role && known.partType
-        ? known
-        : await this.fetchPartMetadata(session.id, session.cwd, props.messageID, props.partID)
-    if (metadata?.role !== "assistant") return
-    if (metadata.partType === "text" && props.field === "text" && metadata.ignored !== true) {
-      await this.input.connection.sessionUpdate({
-        sessionId: session.id,
-        update: {
-          sessionUpdate: "agent_message_chunk",
-          messageId: props.messageID,
-          content: {
-            type: "text",
-            text: props.delta,
-          },
-        },
-      })
-      return
-    }
-
-    if (metadata.partType === "reasoning" && props.field === "text") {
-      await this.input.connection.sessionUpdate({
-        sessionId: session.id,
-        update: {
-          sessionUpdate: "agent_thought_chunk",
-          messageId: props.messageID,
-          content: {
-            type: "text",
-            text: props.delta,
-          },
-        },
-      })
-    }
-  }
-
-  private async fetchPartMetadata(sessionId: string, cwd: string, messageId: string, partId: string) {
-    const message = await this.input.sdk.session
-      .message(
-        {
-          sessionID: sessionId,
-          messageID: messageId,
-          directory: cwd,
-        },
-        { throwOnError: true },
-      )
-      .then((response) => response.data)
-      .catch(() => undefined)
-    if (!message) return
-
-    const part = message.parts.find((item) => item.id === partId)
-    if (!part) return
-    return await this.recordFetchedPart(sessionId, message, part)
-  }
-
-  private async recordFetchedPart(sessionId: string, message: SessionMessageResponse, part: Part) {
-    return await Effect.runPromise(
-      this.input.session.recordPartMetadata({
-        sessionId,
-        messageId: part.messageID,
-        partId: part.id,
-        partType: part.type,
-        role: message.info.role,
-        ignored: part.type === "text" ? part.ignored : undefined,
-        toolCallId: part.type === "tool" ? part.callID : undefined,
-        metadata: "metadata" in part ? part.metadata : undefined,
-      }),
-    )
-  }
-
-  private async handleToolPart(sessionId: string, part: ToolPart, cwd: string) {
-    await this.toolStart(sessionId, part, cwd)
-
-    switch (part.state.status) {
-      case "pending":
-        this.shellSnapshots.delete(part.callID)
-        return
-
-      case "running":
-        await this.runningTool(sessionId, part, cwd)
-        return
-
-      case "completed":
-        this.clearTool(part.callID)
-        await this.input.connection.sessionUpdate({
-          sessionId,
-          update: {
-            sessionUpdate: "tool_call_update",
-            ...completedToolUpdate({
-              toolCallId: part.callID,
-              toolName: part.tool,
-              state: part.state,
-              cwd,
-            }),
-          },
-        })
-        return
-
-      case "error":
-        this.clearTool(part.callID)
-        await this.input.connection.sessionUpdate({
-          sessionId,
-          update: {
-            sessionUpdate: "tool_call_update",
-            ...errorToolUpdate({
-              toolCallId: part.callID,
-              toolName: part.tool,
-              state: part.state,
-              cwd,
-            }),
-          },
-        })
-        return
-    }
-  }
-
-  private async runningTool(sessionId: string, part: ToolPart, cwd: string) {
-    if (part.state.status !== "running") return
-
-    const output = part.tool === "bash" ? shellOutputSnapshot(part.state) : undefined
-    if (output !== undefined) {
-      if (this.shellSnapshots.get(part.callID) === output) {
-        await this.input.connection.sessionUpdate({
-          sessionId,
-          update: {
-            sessionUpdate: "tool_call_update",
-            ...duplicateRunningToolUpdate({
-              toolCallId: part.callID,
-              toolName: part.tool,
-              state: part.state,
-              cwd,
-            }),
-          },
-        })
-        return
-      }
-      this.shellSnapshots.set(part.callID, output)
-    }
-
-    await this.input.connection.sessionUpdate({
-      sessionId,
-      update: {
-        sessionUpdate: "tool_call_update",
-        ...runningToolUpdate({
-          toolCallId: part.callID,
-          toolName: part.tool,
-          state: part.state,
-          output,
-          cwd,
-        }),
-      },
-    })
-  }
-
-  private async toolStart(sessionId: string, part: ToolPart, cwd: string) {
-    if (this.toolStarts.has(part.callID)) return
-    this.toolStarts.add(part.callID)
-    await this.input.connection.sessionUpdate({
-      sessionId,
-      update: {
-        sessionUpdate: "tool_call",
-        ...pendingToolCall({
-          toolCallId: part.callID,
-          toolName: part.tool,
-          state: part.state,
-          cwd,
-        }),
-      },
-    })
-  }
-
-  private clearTool(toolCallId: string) {
-    this.toolStarts.delete(toolCallId)
-    this.shellSnapshots.delete(toolCallId)
-  }
-}
-
-export * as ACPEvent from "./event"