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>()(
+export class SessionNotFoundError extends Schema.TaggedErrorClass<SessionNotFoundError>()("ACPSessionNotFoundError", {
-  "ACPSessionNotFoundError",
+  sessionId: Schema.String,
-  {
+}) {}
-    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")(
+  const sendUpdate: UsageService.Interface["sendUpdate"] = Effect.fn("ACP.promptUsage.sendUpdate")(function* (params) {
-    function* (params) {
+    const messages = yield* request(
-      const messages = yield* request(
+      () =>
-        () =>
+        sdk.session.messages(
-          sdk.session.messages(
+          {
-            {
+            sessionID: params.sessionID,
-              sessionID: params.sessionID,
+            directory: params.directory,
-              directory: params.directory,
+          },
-            },
+          { throwOnError: true },
-            { 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
-          }),
         ),
-      )
+      "session",
-      if (!messages) return
+    ).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)
+    const message = UsageService.latestAssistantMessage(messages)
-      if (!message?.providerID || !message.modelID) return
+    if (!message?.providerID || !message.modelID) return
 
-      const size = yield* contextLimit({
+    const size = yield* contextLimit({
-        directory: params.directory,
+      directory: params.directory,
-        providerID: ProviderID.make(message.providerID),
+      providerID: ProviderID.make(message.providerID),
-        modelID: ModelID.make(message.modelID),
+      modelID: ModelID.make(message.modelID),
-      })
+    })
-      if (!size) return
+    if (!size) return
 
-      yield* Effect.promise(() =>
+    yield* Effect.promise(() =>
-        params.connection
+      params.connection
-          .sessionUpdate({
+        .sessionUpdate({
-            sessionId: params.sessionID,
+          sessionId: params.sessionID,
-            update: {
+          update: {
-              sessionUpdate: "usage_update",
+            sessionUpdate: "usage_update",
-              used: message.tokens.input + message.tokens.cache.read,
+            used: message.tokens.input + message.tokens.cache.read,
-              size,
+            size,
-              cost: { amount: UsageService.totalSessionCost(messages), currency: "USD" },
+            cost: { amount: UsageService.totalSessionCost(messages), currency: "USD" },
-            },
+          },
-          })
+        })
-          .catch((error) => {
+        .catch((error) => {
-            log.error("failed to send usage update", { 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", () =>
+      ACPProfile.measure("acp.directory.command.list", () => sdk.command.list({ directory }, { throwOnError: true })),
-        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")((
+    const recordPartMetadata: Interface["recordPartMetadata"] = Effect.fn("ACP.Session.recordPartMetadata")((input) => {
-      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([
+    expect(cases.map((error) => ACPError.toRequestError(error).code)).toEqual([-32602, -32602, -32602, -32602, -32602])
-      -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(
+    const requestError = ACPError.toRequestError(new ACPError.UnsupportedOperationError({ method: "session/new" }))
-      new ACPError.UnsupportedOperationError({ method: "session/new" }),
-    )
 
     expect(requestError.code).toBe(-32601)
     expect(requestError.data).toEqual({ method: "session/new" })