@opencode/client 2.0.2 → 2.0.4

package/dist/effect/generated/client.js

@@ -10,10 +10,8 @@ const mapClientError = (error) => HttpClientError.isHttpClientError(error) || Sc
     : error;
 const preserveEffect = () => (effect) => effect;
 const preserveStream = () => (stream) => stream;
-const EndpointHealthGet = (raw) => () => preserveEffect()(raw["health.get"]({}).pipe(Effect.mapError(mapClientError)));
-const adaptGroupHealth = (raw) => ({ get: EndpointHealthGet(raw) });
-const EndpointServerGet = (raw) => () => preserveEffect()(raw["server.get"]({}).pipe(Effect.mapError(mapClientError)));
-const adaptGroupServer = (raw) => ({ get: EndpointServerGet(raw) });
+const EndpointServerStatus = (raw) => () => preserveEffect()(raw["server.status"]({}).pipe(Effect.mapError(mapClientError)));
+const adaptGroupServer = (raw) => ({ status: EndpointServerStatus(raw) });
 const EndpointLocationGet = (raw) => (input) => preserveEffect()(raw["location.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupLocation = (raw) => ({ get: EndpointLocationGet(raw) });
 const EndpointAgentList = (raw) => (input) => preserveEffect()(raw["agent.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
@@ -23,18 +21,15 @@ const adaptGroupAgent = (raw) => ({
     get: EndpointAgentGet(raw),
 });
 const EndpointPluginList = (raw) => (input) => preserveEffect()(raw["plugin.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointPluginAwaitActivation = (raw) => (input) => preserveEffect()(raw["plugin.awaitActivation"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointPluginCheck = (raw) => (input) => preserveEffect()(raw["plugin.check"]({ query: { location: input?.["location"] }, payload: { target: input?.["target"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointPluginUpdate = (raw) => (input) => preserveEffect()(raw["plugin.update"]({ query: { location: input["location"] }, payload: { targets: input["targets"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupPlugin = (raw) => ({
     list: EndpointPluginList(raw),
-    awaitActivation: EndpointPluginAwaitActivation(raw),
     check: EndpointPluginCheck(raw),
     update: EndpointPluginUpdate(raw),
 });
 const EndpointSessionList = (raw) => (input) => preserveEffect()(raw["session.list"]({
     query: {
-        workspace: input?.["workspace"],
         limit: input?.["limit"],
         order: input?.["order"],
         search: input?.["search"],
@@ -72,13 +67,16 @@ const EndpointSessionExport = (raw) => (input) => preserveEffect()(raw["session.
 const EndpointSessionActive = (raw) => () => preserveEffect()(raw["session.active"]({}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointSessionGet = (raw) => (input) => preserveEffect()(raw["session.get"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointSessionRemove = (raw) => (input) => preserveEffect()(raw["session.remove"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointSessionFork = (raw) => (input) => preserveEffect()(raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionFork = (raw) => (input) => preserveEffect()(raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { before: input["before"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointSessionSwitchAgent = (raw) => (input) => preserveEffect()(raw["session.switchAgent"]({ params: { sessionID: input["sessionID"] }, payload: { agent: input["agent"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionSwitchModel = (raw) => (input) => preserveEffect()(raw["session.switchModel"]({ params: { sessionID: input["sessionID"] }, payload: { model: input["model"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointSessionRename = (raw) => (input) => preserveEffect()(raw["session.rename"]({ params: { sessionID: input["sessionID"] }, payload: { title: input["title"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointSessionUpdate = (raw) => (input) => preserveEffect()(raw["session.update"]({
+    params: { sessionID: input["sessionID"] },
+    payload: { title: input["title"], permissions: input["permissions"] },
+}).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionMove = (raw) => (input) => preserveEffect()(raw["session.move"]({
     params: { sessionID: input["sessionID"] },
-    payload: { directory: input["directory"], workspaceID: input["workspaceID"], delivery: input["delivery"] },
+    payload: { directory: input["directory"], delivery: input["delivery"] },
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionPrompt = (raw) => (input) => preserveEffect()(raw["session.prompt"]({
     params: { sessionID: input["sessionID"] },
@@ -96,7 +94,7 @@ const EndpointSessionPrompt = (raw) => (input) => preserveEffect()(raw["session.
 const EndpointSessionCommand = (raw) => (input) => preserveEffect()(raw["session.command"]({
     params: { sessionID: input["sessionID"] },
     payload: {
-        command: input["command"],
+        name: input["name"],
         text: input["text"],
         files: input["files"],
         agents: input["agents"],
@@ -106,7 +104,7 @@ const EndpointSessionCommand = (raw) => (input) => preserveEffect()(raw["session
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionSkill = (raw) => (input) => preserveEffect()(raw["session.skill"]({
     params: { sessionID: input["sessionID"] },
-    payload: { id: input["id"], skill: input["skill"], resume: input["resume"] },
+    payload: { id: input["id"], resume: input["resume"] },
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionSynthetic = (raw) => (input) => preserveEffect()(raw["session.synthetic"]({
     params: { sessionID: input["sessionID"] },
@@ -135,10 +133,16 @@ const EndpointSessionRevertStage = (raw) => (input) => preserveEffect()(raw["ses
 const EndpointSessionRevertClear = (raw) => (input) => preserveEffect()(raw["session.revert.clear"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionRevertCommit = (raw) => (input) => preserveEffect()(raw["session.revert.commit"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionContext = (raw) => (input) => preserveEffect()(raw["session.context"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionDiff = (raw) => (input) => preserveEffect()(raw["session.diff"]({
+    params: { sessionID: input["sessionID"] },
+    query: { from: input["from"], to: input["to"], context: input["context"] },
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointSessionInboxList = (raw) => (input) => preserveEffect()(raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointSessionInboxCancel = (raw) => (input) => preserveEffect()(raw["session.inbox.cancel"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointSessionInboxSteer = (raw) => (input) => preserveEffect()(raw["session.inbox.steer"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointSessionInboxQueue = (raw) => (input) => preserveEffect()(raw["session.inbox.queue"]({ params: { sessionID: input["sessionID"], inboxID: input["inboxID"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointSessionInboxUpdate = (raw) => (input) => preserveEffect()(raw["session.inbox.update"]({
+    params: { sessionID: input["sessionID"], inboxID: input["inboxID"] },
+    payload: { delivery: input["delivery"] },
+}).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionInstructionsEntryList = (raw) => (input) => preserveEffect()(raw["session.instructions.entry.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointSessionInstructionsEntryPut = (raw) => (input) => preserveEffect()(raw["session.instructions.entry.put"]({
     params: { sessionID: input["sessionID"], key: input["key"] },
@@ -150,12 +154,20 @@ const EndpointSessionLog = (raw) => (input) => preserveStream()(Stream.unwrap(ra
     params: { sessionID: input["sessionID"] },
     query: { after: input["after"], follow: input["follow"] },
 }).pipe(Effect.mapError(mapClientError), Effect.map((stream) => stream.pipe(Stream.mapError(mapClientError))))));
-const EndpointSessionInterrupt = (raw) => (input) => preserveEffect()(raw["session.interrupt"]({
+const EndpointSessionInterrupt = (raw) => (input) => preserveEffect()(raw["session.interrupt"]({ params: { sessionID: input["sessionID"] }, query: { resume: input["resume"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointSessionBackground = (raw) => (input) => preserveEffect()(raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointSessionMessageGet = (raw) => (input) => preserveEffect()(raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionFormList = (raw) => (input) => preserveEffect()(raw["session.form.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionFormCreate = (raw) => (input) => preserveEffect()(raw["session.form.create"]({
     params: { sessionID: input["sessionID"] },
-    query: { continue: input["continue"] },
+    payload: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
+}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionFormGet = (raw) => (input) => preserveEffect()(raw["session.form.get"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionFormReply = (raw) => (input) => preserveEffect()(raw["session.form.reply"]({
+    params: { sessionID: input["sessionID"], formID: input["formID"] },
+    payload: { answer: input["answer"] },
 }).pipe(Effect.mapError(mapClientError)));
-const EndpointSessionBackground = (raw) => (input) => preserveEffect()(raw["session.background"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointSessionMessage = (raw) => (input) => preserveEffect()(raw["session.message"]({ params: { sessionID: input["sessionID"], messageID: input["messageID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
+const EndpointSessionFormCancel = (raw) => (input) => preserveEffect()(raw["session.form.cancel"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointSessionEnvironment = (raw) => (input) => preserveEffect()(raw["session.environment"]({
     params: { sessionID: input["sessionID"] },
     payload: { variables: input["variables"] },
@@ -173,7 +185,7 @@ const adaptGroupSession = (raw) => ({
     fork: EndpointSessionFork(raw),
     switchAgent: EndpointSessionSwitchAgent(raw),
     switchModel: EndpointSessionSwitchModel(raw),
-    rename: EndpointSessionRename(raw),
+    update: EndpointSessionUpdate(raw),
     move: EndpointSessionMove(raw),
     prompt: EndpointSessionPrompt(raw),
     command: EndpointSessionCommand(raw),
@@ -188,11 +200,11 @@ const adaptGroupSession = (raw) => ({
         commit: EndpointSessionRevertCommit(raw),
     },
     context: EndpointSessionContext(raw),
+    diff: EndpointSessionDiff(raw),
     inbox: {
         list: EndpointSessionInboxList(raw),
         cancel: EndpointSessionInboxCancel(raw),
-        steer: EndpointSessionInboxSteer(raw),
-        queue: EndpointSessionInboxQueue(raw),
+        update: EndpointSessionInboxUpdate(raw),
     },
     instructions: {
         entry: {
@@ -205,7 +217,14 @@ const adaptGroupSession = (raw) => ({
     log: EndpointSessionLog(raw),
     interrupt: EndpointSessionInterrupt(raw),
     background: EndpointSessionBackground(raw),
-    message: EndpointSessionMessage(raw),
+    message: { get: EndpointSessionMessageGet(raw) },
+    form: {
+        list: EndpointSessionFormList(raw),
+        create: EndpointSessionFormCreate(raw),
+        get: EndpointSessionFormGet(raw),
+        reply: EndpointSessionFormReply(raw),
+        cancel: EndpointSessionFormCancel(raw),
+    },
     environment: EndpointSessionEnvironment(raw),
     view: EndpointSessionView(raw),
 });
@@ -307,17 +326,10 @@ const adaptGroupMcp = (raw) => ({
 });
 const EndpointCredentialUpdate = (raw) => (input) => preserveEffect()(raw["credential.update"]({
     params: { credentialID: input["credentialID"] },
-    query: { location: input["location"] },
     payload: { label: input["label"] },
 }).pipe(Effect.mapError(mapClientError)));
-const EndpointCredentialActivate = (raw) => (input) => preserveEffect()(raw["credential.activate"]({
-    params: { credentialID: input["credentialID"] },
-    query: { location: input["location"] },
-}).pipe(Effect.mapError(mapClientError)));
-const EndpointCredentialRemove = (raw) => (input) => preserveEffect()(raw["credential.remove"]({
-    params: { credentialID: input["credentialID"] },
-    query: { location: input["location"] },
-}).pipe(Effect.mapError(mapClientError)));
+const EndpointCredentialActivate = (raw) => (input) => preserveEffect()(raw["credential.activate"]({ params: { credentialID: input["credentialID"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointCredentialRemove = (raw) => (input) => preserveEffect()(raw["credential.remove"]({ params: { credentialID: input["credentialID"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupCredential = (raw) => ({
     update: EndpointCredentialUpdate(raw),
     activate: EndpointCredentialActivate(raw),
@@ -328,34 +340,12 @@ const EndpointProjectUpdate = (raw) => (input) => preserveEffect()(raw["project.
     params: { projectID: input["projectID"] },
     payload: { canonical: input["canonical"], name: input["name"], icon: input["icon"], commands: input["commands"] },
 }).pipe(Effect.mapError(mapClientError)));
-const EndpointProjectCurrent = (raw) => (input) => preserveEffect()(raw["project.current"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupProject = (raw) => ({
     list: EndpointProjectList(raw),
     update: EndpointProjectUpdate(raw),
-    current: EndpointProjectCurrent(raw),
-});
-const EndpointFormRequestList = (raw) => (input) => preserveEffect()(raw["form.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointFormList = (raw) => (input) => preserveEffect()(raw["session.form.list"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
-const EndpointFormCreate = (raw) => (input) => preserveEffect()(raw["session.form.create"]({
-    params: { sessionID: input["sessionID"] },
-    payload: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
-}).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
-const EndpointFormGet = (raw) => (input) => preserveEffect()(raw["session.form.get"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
-const EndpointFormState = (raw) => (input) => preserveEffect()(raw["session.form.state"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
-const EndpointFormReply = (raw) => (input) => preserveEffect()(raw["session.form.reply"]({
-    params: { sessionID: input["sessionID"], formID: input["formID"] },
-    payload: { answer: input["answer"] },
-}).pipe(Effect.mapError(mapClientError)));
-const EndpointFormCancel = (raw) => (input) => preserveEffect()(raw["session.form.cancel"]({ params: { sessionID: input["sessionID"], formID: input["formID"] } }).pipe(Effect.mapError(mapClientError)));
-const adaptGroupForm = (raw) => ({
-    request: { list: EndpointFormRequestList(raw) },
-    list: EndpointFormList(raw),
-    create: EndpointFormCreate(raw),
-    get: EndpointFormGet(raw),
-    state: EndpointFormState(raw),
-    reply: EndpointFormReply(raw),
-    cancel: EndpointFormCancel(raw),
 });
+const EndpointFormList = (raw) => (input) => preserveEffect()(raw["form.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+const adaptGroupForm = (raw) => ({ list: EndpointFormList(raw) });
 const EndpointPermissionRequestList = (raw) => (input) => preserveEffect()(raw["permission.request.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointPermissionSavedList = (raw) => (input) => preserveEffect()(raw["permission.saved.list"]({ query: { projectID: input?.["projectID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointPermissionSavedRemove = (raw) => (input) => preserveEffect()(raw["permission.saved.remove"]({ params: { id: input["id"] } }).pipe(Effect.mapError(mapClientError)));
@@ -375,11 +365,7 @@ const EndpointPermissionList = (raw) => (input) => preserveEffect()(raw["session
 const EndpointPermissionGet = (raw) => (input) => preserveEffect()(raw["session.permission.get"]({ params: { sessionID: input["sessionID"], requestID: input["requestID"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
 const EndpointPermissionReply = (raw) => (input) => preserveEffect()(raw["session.permission.reply"]({
     params: { sessionID: input["sessionID"], requestID: input["requestID"] },
-    payload: { reply: input["reply"], message: input["message"] },
-}).pipe(Effect.mapError(mapClientError)));
-const EndpointPermissionRules = (raw) => (input) => preserveEffect()(raw["session.permission.rules"]({
-    params: { sessionID: input["sessionID"] },
-    payload: { permissions: input["permissions"] },
+    payload: { decision: input["decision"], message: input["message"] },
 }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupPermission = (raw) => ({
     request: { list: EndpointPermissionRequestList(raw) },
@@ -388,7 +374,6 @@ const adaptGroupPermission = (raw) => ({
     list: EndpointPermissionList(raw),
     get: EndpointPermissionGet(raw),
     reply: EndpointPermissionReply(raw),
-    rules: EndpointPermissionRules(raw),
 });
 const EndpointFileList = (raw) => (input) => preserveEffect()(raw["fs.list"]({ query: { location: input?.["location"], path: input?.["path"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointFileFind = (raw) => (input) => preserveEffect()(raw["fs.find"]({
@@ -484,11 +469,6 @@ const EndpointShellCreate = (raw) => (input) => preserveEffect()(raw["shell.crea
     payload: { command: input["command"], cwd: input["cwd"], timeout: input["timeout"], metadata: input["metadata"] },
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointShellGet = (raw) => (input) => preserveEffect()(raw["shell.get"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointShellTimeout = (raw) => (input) => preserveEffect()(raw["shell.timeout"]({
-    params: { id: input["id"] },
-    query: { location: input["location"] },
-    payload: { timeout: input["timeout"] },
-}).pipe(Effect.mapError(mapClientError)));
 const EndpointShellOutput = (raw) => (input) => preserveEffect()(raw["shell.output"]({
     params: { id: input["id"] },
     query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
@@ -498,44 +478,35 @@ const adaptGroupShell = (raw) => ({
     list: EndpointShellList(raw),
     create: EndpointShellCreate(raw),
     get: EndpointShellGet(raw),
-    timeout: EndpointShellTimeout(raw),
     output: EndpointShellOutput(raw),
     remove: EndpointShellRemove(raw),
 });
 const EndpointReferenceList = (raw) => (input) => preserveEffect()(raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupReference = (raw) => ({ list: EndpointReferenceList(raw) });
-const EndpointWorktreeList = (raw) => (input) => preserveEffect()(raw["worktree.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointWorktreeList = (raw) => (input) => preserveEffect()(raw["worktree.list"]({ query: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointWorktreeCreate = (raw) => (input) => preserveEffect()(raw["worktree.create"]({
-    query: { location: input?.["location"] },
     payload: {
-        strategy: input?.["strategy"],
-        from: input?.["from"],
-        branch: input?.["branch"],
-        directory: input?.["directory"],
-        name: input?.["name"],
+        projectID: input["projectID"],
+        from: input["from"],
+        branch: input["branch"],
+        directory: input["directory"],
+        name: input["name"],
     },
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointWorktreeRemove = (raw) => (input) => preserveEffect()(raw["worktree.remove"]({
-    query: { location: input["location"] },
-    payload: { directory: input["directory"], force: input["force"] },
+    payload: { projectID: input["projectID"], directory: input["directory"], force: input["force"] },
 }).pipe(Effect.mapError(mapClientError)));
-const EndpointWorktreeRefresh = (raw) => (input) => preserveEffect()(raw["worktree.refresh"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
+const EndpointWorktreeRefresh = (raw) => (input) => preserveEffect()(raw["worktree.refresh"]({ payload: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupWorktree = (raw) => ({
     list: EndpointWorktreeList(raw),
     create: EndpointWorktreeCreate(raw),
     remove: EndpointWorktreeRemove(raw),
     refresh: EndpointWorktreeRefresh(raw),
 });
-const EndpointWorkspaceCreate = (raw) => (input) => preserveEffect()(raw["workspace.create"]({ payload: { id: input["id"], provider: input["provider"] } }).pipe(Effect.mapError(mapClientError), Effect.map((value) => value.data)));
-const EndpointWorkspaceDestroy = (raw) => (input) => preserveEffect()(raw["workspace.destroy"]({ params: { workspaceID: input["workspaceID"] } }).pipe(Effect.mapError(mapClientError)));
-const adaptGroupWorkspace = (raw) => ({
-    create: EndpointWorkspaceCreate(raw),
-    destroy: EndpointWorkspaceDestroy(raw),
-});
 const EndpointVcsGet = (raw) => (input) => preserveEffect()(raw["vcs.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointVcsBase = (raw) => (input) => preserveEffect()(raw["vcs.base"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointVcsStatus = (raw) => (input) => preserveEffect()(raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointVcsBranches = (raw) => (input) => preserveEffect()(raw["vcs.branches"]({
+const EndpointVcsBranchList = (raw) => (input) => preserveEffect()(raw["vcs.branch.list"]({
     query: { location: input?.["location"], search: input?.["search"], limit: input?.["limit"] },
 }).pipe(Effect.mapError(mapClientError)));
 const EndpointVcsDiff = (raw) => (input) => preserveEffect()(raw["vcs.diff"]({
@@ -545,7 +516,7 @@ const adaptGroupVcs = (raw) => ({
     get: EndpointVcsGet(raw),
     base: EndpointVcsBase(raw),
     status: EndpointVcsStatus(raw),
-    branches: EndpointVcsBranches(raw),
+    branch: { list: EndpointVcsBranchList(raw) },
     diff: EndpointVcsDiff(raw),
 });
 const EndpointDebugLocationList = (raw) => () => preserveEffect()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)));
@@ -565,17 +536,14 @@ const adaptGroupWebsearch = (raw) => ({
     query: EndpointWebsearchQuery(raw),
 });
 const EndpointConfigGet = (raw) => (input) => preserveEffect()(raw["config.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)));
-const EndpointConfigPreferences = (raw) => () => preserveEffect()(raw["config.preferences"]({}).pipe(Effect.mapError(mapClientError)));
-const EndpointConfigUpdatePreferences = (raw) => (input) => preserveEffect()(raw["config.updatePreferences"]({ payload: { shell: input?.["shell"], websearch: input?.["websearch"] } }).pipe(Effect.mapError(mapClientError)));
 const EndpointConfigShells = (raw) => () => preserveEffect()(raw["config.shells"]({}).pipe(Effect.mapError(mapClientError)));
+const EndpointConfigUpdate = (raw) => (input) => preserveEffect()(raw["config.update"]({ payload: { shell: input["shell"] } }).pipe(Effect.mapError(mapClientError)));
 const adaptGroupConfig = (raw) => ({
     get: EndpointConfigGet(raw),
-    preferences: EndpointConfigPreferences(raw),
-    updatePreferences: EndpointConfigUpdatePreferences(raw),
     shells: EndpointConfigShells(raw),
+    update: EndpointConfigUpdate(raw),
 });
 const adaptClient = (raw) => ({
-    health: adaptGroupHealth(raw["server.health"]),
     server: adaptGroupServer(raw["server.server"]),
     location: adaptGroupLocation(raw["server.location"]),
     agent: adaptGroupAgent(raw["server.agent"]),
@@ -601,7 +569,6 @@ const adaptClient = (raw) => ({
     shell: adaptGroupShell(raw["server.shell"]),
     reference: adaptGroupReference(raw["server.reference"]),
     worktree: adaptGroupWorktree(raw["server.worktree"]),
-    workspace: adaptGroupWorkspace(raw["server.workspace"]),
     vcs: adaptGroupVcs(raw["server.vcs"]),
     debug: adaptGroupDebug(raw["server.debug"]),
     migration: adaptGroupMigration(raw["server.migration"]),

package/dist/effect/index.d.ts

@@ -2,7 +2,7 @@ import type { Effect } from "effect";
 import type { OpenCode } from "./client.js";
 export * from "./generated/index";
 export { OpenCode } from "./client.js";
-export type { AgentApi, AppApi, CatalogApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, RpcApi, RpcClient, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
+export type { AgentApi, AppApi, CommandApi, ConfigApi, EventApi, IntegrationApi, ModelApi, PluginApi, ProviderApi, ReferenceApi, RpcApi, RpcClient, WebSearchApi, SessionApi, SkillApi, } from "./api.js";
 export { Agent } from "@opencode/schema/agent";
 export { Command } from "@opencode/schema/command";
 export { Config } from "@opencode/schema/config";

package/dist/effect/service.js

@@ -1,4 +1,3 @@
-import { ServiceStatus } from "@opencode/protocol/groups/health";
 import { Effect, FileSystem, Option, Schedule, Schema } from "effect";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -21,6 +20,8 @@ export const discover = Effect.fn("service.discover")(function* (options = {}) {
     const found = (yield* registered(options.file)).service;
     if (found?.state !== "ready")
         return undefined;
+    if (!found.compatible)
+        return undefined;
     if (!matchesVersion(found.version, options))
         return undefined;
     return found.endpoint;
@@ -29,7 +30,9 @@ export const discover = Effect.fn("service.discover")(function* (options = {}) {
 export const incumbent = Effect.fn("service.incumbent")(function* (options) {
     const info = yield* read(options.file);
     const found = info === undefined ? undefined : yield* probe({ ...info, url: options.url });
-    if (found === undefined || found.legacy)
+    if (found === undefined)
+        return undefined;
+    if (!found.compatible)
         return undefined;
     if (!matchesVersion(found.version, options))
         return undefined;
@@ -65,7 +68,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
         });
     });
     const found = yield* Effect.gen(function* () {
-        const registration = yield* registered(options.file, true, timing.requestTimeout);
+        const registration = yield* registered(options.file, timing.requestTimeout);
         const info = registration.info;
         const service = registration.service;
         if (registration.timedOut && info !== undefined) {
@@ -86,7 +89,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
             timeouts = undefined;
         if (service !== undefined) {
             spawnDelay = timing.spawnDelay;
-            const compatible = !service.legacy && matchesVersion(service.version, options);
+            const compatible = service.compatible && matchesVersion(service.version, options);
             if (compatible && service.state === "ready") {
                 yield* Effect.tryPromise(() => PtyHandoff.complete(options.file ?? fallback(), service.info));
                 return Option.some(service);
@@ -96,11 +99,11 @@ export const ensure = Effect.fn("service.ensure")(function* (options = {}) {
             if (compatible)
                 return Option.none();
             yield* announce("version-mismatch", service.version);
-            if (!service.legacy && service.state !== "ready")
+            if (service.state !== "ready")
                 yield* Effect.logWarning("Background service is not ready; replacement cannot preserve persistent terminals");
             yield* stop({
                 file: options.file,
-                pty: !service.legacy && service.state === "ready" ? "handoff" : "clear",
+                pty: service.state === "ready" ? "handoff" : "clear",
             }).pipe(Effect.ignore);
             lastSpawn = 0;
             return Option.none();
@@ -159,8 +162,10 @@ export const Info = Schema.Struct({
     password: Schema.optional(Schema.String),
 });
 const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Info));
-const decodeHealth = Schema.decodeUnknownOption(ServiceStatus.Health);
-const decodeLegacyHealth = Schema.decodeUnknownOption(Schema.Struct({ healthy: Schema.Literal(true) }));
+const decodeStatus = Schema.decodeUnknownOption(Schema.Struct({
+    version: Schema.String,
+    pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+}));
 // A missing or corrupt file means no valid info; callers treat both
 // the same (the registering server self-evicts, clients rediscover).
 const read = Effect.fnUntraced(function* (file) {
@@ -170,10 +175,10 @@ const read = Effect.fnUntraced(function* (file) {
         return undefined;
     return yield* decode(text.value).pipe(Effect.option, Effect.map(Option.getOrUndefined));
 });
-const probe = Effect.fnUntraced(function* (info, allowLegacy = false) {
-    return (yield* probeResult(info, allowLegacy)).service;
+const probe = Effect.fnUntraced(function* (info) {
+    return (yield* probeResult(info)).service;
 });
-const probeResult = Effect.fnUntraced(function* (info, allowLegacy = false, timeout = defaultEnsureTiming.requestTimeout) {
+const probeResult = Effect.fnUntraced(function* (info, timeout = defaultEnsureTiming.requestTimeout) {
     const endpoint = {
         url: info.url,
         auth: info.password === undefined
@@ -181,47 +186,53 @@ const probeResult = Effect.fnUntraced(function* (info, allowLegacy = false, time
             : { type: "basic", username: "opencode", password: info.password },
     };
     const signal = AbortSignal.timeout(timeout);
-    const result = yield* Effect.promise(() => fetch(new URL("/api/health", info.url), {
-        headers: headers(endpoint),
-        signal,
-    })
-        .then(async (response) => ({ response, body: (await response.json()) }))
+    const result = yield* Effect.promise(() => fetch(new URL("/api/status", info.url), { headers: headers(endpoint), signal })
+        .then(async (response) => ({
+        response,
+        body: response.status === 404 ? undefined : (await response.json()),
+    }))
         .then((value) => ({ value }), (cause) => ({ cause })));
     if ("cause" in result)
         return { service: undefined, timedOut: signal.aborted };
     const response = result.value.response;
+    // The previous V2 service exposes /api/health instead. Its authenticated 404 is enough
+    // to recognize the registered daemon as incompatible and route it through replacement.
+    if (response.status === 404)
+        return {
+            service: {
+                info,
+                endpoint,
+                version: info.version,
+                state: "ready",
+                compatible: false,
+            },
+            timedOut: false,
+        };
     const body = result.value.body;
-    const health = decodeHealth(body);
-    if (Option.isSome(health)) {
-        if (health.value.pid !== info.pid)
+    const status = decodeStatus(body);
+    if (Option.isSome(status)) {
+        if (status.value.pid !== info.pid)
             return { service: undefined, timedOut: false };
-        if (info.version !== undefined && health.value.version !== info.version)
+        if (info.version !== undefined && status.value.version !== info.version)
             return { service: undefined, timedOut: false };
         return {
             service: {
                 info,
                 endpoint,
-                version: health.value.version,
+                version: status.value.version,
                 state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
-                legacy: false,
+                compatible: true,
             },
             timedOut: false,
         };
     }
-    if (!allowLegacy ||
-        Option.isNone(decodeLegacyHealth(body)) ||
-        (typeof body === "object" && body !== null && ("version" in body || "pid" in body)))
-        return { service: undefined, timedOut: false };
-    return {
-        service: { info, endpoint, state: "ready", legacy: true },
-        timedOut: false,
-    };
+    return { service: undefined, timedOut: false };
 });
-const registered = Effect.fnUntraced(function* (file, allowLegacy = false, timeout) {
+const registered = Effect.fnUntraced(function* (file, timeout) {
     const info = yield* read(file);
     if (info === undefined)
         return { info: undefined, service: undefined, timedOut: false };
-    return { info, ...(yield* probeResult(info, allowLegacy, timeout)) };
+    return { info, ...(yield* probeResult(info, timeout)) };
 });
 // 50ms cadence bounded at ~5s, shared by stop escalation and each ensure
 // discovery window.

package/dist/promise/api.d.ts

@@ -18,7 +18,3 @@ export type SessionApi = Client["session"];
 export type SkillApi = Client["skill"];
 export type VcsApi = Client["vcs"];
 export type WorktreeApi = Client["worktree"];
-export interface CatalogApi {
-    readonly provider: ProviderApi;
-    readonly model: ModelApi;
-}