chore: generate

packages/opencode/src/acp/error.ts

@@ -1,12 +1,9 @@
 import { RequestError } from "@agentclientprotocol/sdk"
 import { Schema } from "effect"
 
-export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()(
-  "ACPSessionNotFoundError",
-  {
-    sessionId: Schema.String,
-  },
-) {}
+export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()("ACPSessionNotFoundError", {
+  sessionId: Schema.String,
+}) {}
 
 export class InvalidConfigOptionError extends Schema.TaggedErrorClass<InvalidConfigOptionError>()(
   "ACPInvalidConfigOptionError",

packages/opencode/src/acp/service.ts

@@ -615,56 +615,54 @@ function makeUsageService(sdk: OpencodeClient) {
     },
   )
 
-  const sendUpdate: UsageService.Interface["sendUpdate"] = Effect.fn("ACP.promptUsage.sendUpdate")(
-    function* (params) {
-      const messages = yield* request(
-        () =>
-          sdk.session.messages(
-            {
-              sessionID: params.sessionID,
-              directory: params.directory,
-            },
-            { throwOnError: true },
-          ),
-        "session",
-      ).pipe(
-        Effect.map((messages) => messages as readonly UsageService.SessionMessage[]),
-        Effect.catch((error) =>
-          Effect.sync(() => {
-            log.error("failed to fetch messages for usage update", { error })
-            return undefined
-          }),
+  const sendUpdate: UsageService.Interface["sendUpdate"] = Effect.fn("ACP.promptUsage.sendUpdate")(function* (params) {
+    const messages = yield* request(
+      () =>
+        sdk.session.messages(
+          {
+            sessionID: params.sessionID,
+            directory: params.directory,
+          },
+          { throwOnError: true },
         ),
-      )
-      if (!messages) return
+      "session",
+    ).pipe(
+      Effect.map((messages) => messages as readonly UsageService.SessionMessage[]),
+      Effect.catch((error) =>
+        Effect.sync(() => {
+          log.error("failed to fetch messages for usage update", { error })
+          return undefined
+        }),
+      ),
+    )
+    if (!messages) return
 
-      const message = UsageService.latestAssistantMessage(messages)
-      if (!message?.providerID || !message.modelID) return
+    const message = UsageService.latestAssistantMessage(messages)
+    if (!message?.providerID || !message.modelID) return
 
-      const size = yield* contextLimit({
-        directory: params.directory,
-        providerID: ProviderID.make(message.providerID),
-        modelID: ModelID.make(message.modelID),
-      })
-      if (!size) return
-
-      yield* Effect.promise(() =>
-        params.connection
-          .sessionUpdate({
-            sessionId: params.sessionID,
-            update: {
-              sessionUpdate: "usage_update",
-              used: message.tokens.input + message.tokens.cache.read,
-              size,
-              cost: { amount: UsageService.totalSessionCost(messages), currency: "USD" },
-            },
-          })
-          .catch((error) => {
-            log.error("failed to send usage update", { error })
-          }),
-      )
-    },
-  )
+    const size = yield* contextLimit({
+      directory: params.directory,
+      providerID: ProviderID.make(message.providerID),
+      modelID: ModelID.make(message.modelID),
+    })
+    if (!size) return
+
+    yield* Effect.promise(() =>
+      params.connection
+        .sessionUpdate({
+          sessionId: params.sessionID,
+          update: {
+            sessionUpdate: "usage_update",
+            used: message.tokens.input + message.tokens.cache.read,
+            size,
+            cost: { amount: UsageService.totalSessionCost(messages), currency: "USD" },
+          },
+        })
+        .catch((error) => {
+          log.error("failed to send usage update", { error })
+        }),
+    )
+  })
 
   return UsageService.Service.of({
     buildUsage: UsageService.buildUsage,
@@ -736,9 +734,7 @@ async function loadDirectorySnapshot(sdk: OpencodeClient, directory: string) {
       ACPProfile.measure("acp.directory.mode.defaultAgent.load", () =>
         sdk.app.agents({ directory }, { throwOnError: true }),
       ),
-      ACPProfile.measure("acp.directory.command.list", () =>
-        sdk.command.list({ directory }, { throwOnError: true }),
-      ),
+      ACPProfile.measure("acp.directory.command.list", () => sdk.command.list({ directory }, { throwOnError: true })),
       ACPProfile.measure("acp.directory.skill.list", () => sdk.app.skills({ directory }, { throwOnError: true })),
       ACPProfile.measure("acp.directory.defaultModel.config", () =>
         sdk.config.get({ directory }, { throwOnError: true }).catch(() => undefined),

packages/opencode/src/acp/session.ts

@@ -148,9 +148,7 @@ export const layer = Layer.effect(
       update(sessionId, (session) => ({ ...session, modeId })),
     )
 
-    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACP.Session.recordPartMetadata")((
-      input,
-    ) => {
+    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACP.Session.recordPartMetadata")((input) => {
       const metadata = {
         messageId: input.messageId,
         partId: input.partId,

packages/opencode/test/acp/error.test.ts

@@ -12,9 +12,7 @@ describe("acp.error", () => {
       new ACPError.InvalidModeError({ mode: "turbo" }),
     ]
 
-    expect(cases.map((error) => ACPError.toRequestError(error).code)).toEqual([
-      -32602, -32602, -32602, -32602, -32602,
-    ])
+    expect(cases.map((error) => ACPError.toRequestError(error).code)).toEqual([-32602, -32602, -32602, -32602, -32602])
   })
 
   test("includes safe validation details", () => {
@@ -38,9 +36,7 @@ describe("acp.error", () => {
   })
 
   test("maps unsupported operations to method not found", () => {
-    const requestError = ACPError.toRequestError(
-      new ACPError.UnsupportedOperationError({ method: "session/new" }),
-    )
+    const requestError = ACPError.toRequestError(new ACPError.UnsupportedOperationError({ method: "session/new" }))
 
     expect(requestError.code).toBe(-32601)
     expect(requestError.data).toEqual({ method: "session/new" })