@opencode/client 0.0.0-dev-19574 → 0.0.0-dev-19578

package/dist/effect/api/api.d.ts

@@ -253,7 +253,7 @@ export type SessionRemoveOutput = void;
 export type SessionRemoveOperation<E = never> = (input: SessionRemoveInput) => Effect.Effect<SessionRemoveOutput, E>;
 export type SessionForkInput = {
     readonly sessionID: Session.ID;
-    readonly boundary: Session.ForkRequestBoundary;
+    readonly before?: SessionMessage.ID | undefined;
 };
 export type SessionForkOutput = Session.Info;
 export type SessionForkOperation<E = never> = (input: SessionForkInput) => Effect.Effect<SessionForkOutput, E>;
@@ -1897,26 +1897,17 @@ export interface McpApi<E = never> {
 }
 export type CredentialUpdateInput = {
     readonly credentialID: Credential.ID;
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
     readonly label: string;
 };
 export type CredentialUpdateOutput = void;
 export type CredentialUpdateOperation<E = never> = (input: CredentialUpdateInput) => Effect.Effect<CredentialUpdateOutput, E>;
 export type CredentialActivateInput = {
     readonly credentialID: Credential.ID;
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
 };
 export type CredentialActivateOutput = void;
 export type CredentialActivateOperation<E = never> = (input: CredentialActivateInput) => Effect.Effect<CredentialActivateOutput, E>;
 export type CredentialRemoveInput = {
     readonly credentialID: Credential.ID;
-    readonly location?: {
-        readonly directory?: string | undefined;
-    } | undefined;
 };
 export type CredentialRemoveOutput = void;
 export type CredentialRemoveOperation<E = never> = (input: CredentialRemoveInput) => Effect.Effect<CredentialRemoveOutput, E>;

package/dist/effect/client.d.ts

@@ -2304,17 +2304,17 @@ export declare const make: (options?: {
             add: (input: import("./api.js").IntegrationWellknownAddInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
         };
         connect: {
-            key: (input: import("./api.js").IntegrationConnectKeyInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+            key: (input: import("./api.js").IntegrationConnectKeyInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
         };
         oauth: {
             connect: (input: import("./api.js").IntegrationOauthConnectInput) => Effect.Effect<import("./api.js").IntegrationOauthConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
-            status: (input: import("./api.js").IntegrationOauthStatusInput) => Effect.Effect<import("./api.js").IntegrationOauthStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
-            complete: (input: import("./api.js").IntegrationOauthCompleteInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+            status: (input: import("./api.js").IntegrationOauthStatusInput) => Effect.Effect<import("./api.js").IntegrationOauthStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+            complete: (input: import("./api.js").IntegrationOauthCompleteInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
             cancel: (input: import("./api.js").IntegrationOauthCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
         };
         command: {
-            connect: (input: import("./api.js").IntegrationCommandConnectInput) => Effect.Effect<import("./api.js").IntegrationCommandConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
-            status: (input: import("./api.js").IntegrationCommandStatusInput) => Effect.Effect<import("./api.js").IntegrationCommandStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+            connect: (input: import("./api.js").IntegrationCommandConnectInput) => Effect.Effect<import("./api.js").IntegrationCommandConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationMethodNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+            status: (input: import("./api.js").IntegrationCommandStatusInput) => Effect.Effect<import("./api.js").IntegrationCommandStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
             cancel: (input: import("./api.js").IntegrationCommandCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("effect/Schema").SchemaError | ClientError | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
         };
     };

package/dist/effect/generated/client.d.ts

@@ -91,17 +91,17 @@ export declare const make: (options?: {
             add: (input: IntegrationWellknownAddInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
         };
         connect: {
-            key: (input: IntegrationConnectKeyInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
+            key: (input: IntegrationConnectKeyInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
         };
         oauth: {
             connect: (input: IntegrationOauthConnectInput) => Effect.Effect<IntegrationOauthConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
-            status: (input: IntegrationOauthStatusInput) => Effect.Effect<IntegrationOauthStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
-            complete: (input: IntegrationOauthCompleteInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
+            status: (input: IntegrationOauthStatusInput) => Effect.Effect<IntegrationOauthStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
+            complete: (input: IntegrationOauthCompleteInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
             cancel: (input: IntegrationOauthCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
         };
         command: {
-            connect: (input: IntegrationCommandConnectInput) => Effect.Effect<IntegrationCommandConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
-            status: (input: IntegrationCommandStatusInput) => Effect.Effect<IntegrationCommandStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
+            connect: (input: IntegrationCommandConnectInput) => Effect.Effect<IntegrationCommandConnectOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationMethodNotFoundError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
+            status: (input: IntegrationCommandStatusInput) => Effect.Effect<IntegrationCommandStatusOutput, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | import("@opencode/protocol/errors").IntegrationNotFoundError | import("@opencode/protocol/errors").IntegrationAttemptNotFoundError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
             cancel: (input: IntegrationCommandCancelInput) => Effect.Effect<void, import("@opencode/protocol/errors").InvalidRequestError | import("@opencode/protocol/errors").UnauthorizedError | Schema.SchemaError | ClientError | HttpClientError.HttpClientError, never>;
         };
     };

package/dist/effect/generated/client.js

@@ -67,7 +67,7 @@ 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)));
@@ -307,17 +307,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),

package/dist/promise/generated/client.js

@@ -208,7 +208,7 @@ export function make(options) {
             }, requestOptions),
             stats: (input, requestOptions) => request({
                 method: "GET",
-                path: `/api/session/stats`,
+                path: `/api/experimental/session/stats`,
                 query: {
                     from: input?.["from"],
                     to: input?.["to"],
@@ -276,7 +276,7 @@ export function make(options) {
             fork: (input, requestOptions) => request({
                 method: "POST",
                 path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
-                body: { boundary: input["boundary"] },
+                body: { before: input["before"] },
                 successStatus: 200,
                 declaredStatuses: [400, 401, 404],
                 empty: false,
@@ -632,7 +632,7 @@ export function make(options) {
                     query: { location: input["location"] },
                     body: { key: input["key"], answer: input["answer"], label: input["label"] },
                     successStatus: 204,
-                    declaredStatuses: [400, 401],
+                    declaredStatuses: [400, 401, 404],
                     empty: true,
                 }, requestOptions),
             },
@@ -651,7 +651,7 @@ export function make(options) {
                     path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
                     query: { location: input["location"] },
                     successStatus: 200,
-                    declaredStatuses: [400, 401],
+                    declaredStatuses: [400, 401, 404],
                     empty: false,
                 }, requestOptions),
                 complete: (input, requestOptions) => request({
@@ -660,7 +660,7 @@ export function make(options) {
                     query: { location: input["location"] },
                     body: { code: input["code"] },
                     successStatus: 204,
-                    declaredStatuses: [400, 401],
+                    declaredStatuses: [400, 401, 404],
                     empty: true,
                 }, requestOptions),
                 cancel: (input, requestOptions) => request({
@@ -679,7 +679,7 @@ export function make(options) {
                     query: { location: input["location"] },
                     body: { methodID: input["methodID"], label: input["label"] },
                     successStatus: 200,
-                    declaredStatuses: [400, 401],
+                    declaredStatuses: [400, 401, 404],
                     empty: false,
                 }, requestOptions),
                 status: (input, requestOptions) => request({
@@ -687,7 +687,7 @@ export function make(options) {
                     path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
                     query: { location: input["location"] },
                     successStatus: 200,
-                    declaredStatuses: [400, 401],
+                    declaredStatuses: [400, 401, 404],
                     empty: false,
                 }, requestOptions),
                 cancel: (input, requestOptions) => request({
@@ -711,7 +711,7 @@ export function make(options) {
             }, requestOptions),
             add: (input, requestOptions) => request({
                 method: "PUT",
-                path: `/api/mcp/${encodeURIComponent(input.server)}`,
+                path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
                 query: { location: input["location"] },
                 body: { config: input["config"] },
                 successStatus: 204,
@@ -720,7 +720,7 @@ export function make(options) {
             }, requestOptions),
             remove: (input, requestOptions) => request({
                 method: "DELETE",
-                path: `/api/mcp/${encodeURIComponent(input.server)}`,
+                path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
                 query: { location: input["location"] },
                 successStatus: 204,
                 declaredStatuses: [400, 401, 404],
@@ -728,7 +728,7 @@ export function make(options) {
             }, requestOptions),
             connect: (input, requestOptions) => request({
                 method: "POST",
-                path: `/api/mcp/${encodeURIComponent(input.server)}/connect`,
+                path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/connect`,
                 query: { location: input["location"] },
                 successStatus: 204,
                 declaredStatuses: [400, 401, 404],
@@ -736,7 +736,7 @@ export function make(options) {
             }, requestOptions),
             disconnect: (input, requestOptions) => request({
                 method: "POST",
-                path: `/api/mcp/${encodeURIComponent(input.server)}/disconnect`,
+                path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/disconnect`,
                 query: { location: input["location"] },
                 successStatus: 204,
                 declaredStatuses: [400, 401, 404],
@@ -757,7 +757,6 @@ export function make(options) {
             update: (input, requestOptions) => request({
                 method: "PATCH",
                 path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
-                query: { location: input["location"] },
                 body: { label: input["label"] },
                 successStatus: 204,
                 declaredStatuses: [400, 401],
@@ -766,7 +765,6 @@ export function make(options) {
             activate: (input, requestOptions) => request({
                 method: "POST",
                 path: `/api/credential/${encodeURIComponent(input.credentialID)}/activate`,
-                query: { location: input["location"] },
                 successStatus: 204,
                 declaredStatuses: [400, 401],
                 empty: true,
@@ -774,7 +772,6 @@ export function make(options) {
             remove: (input, requestOptions) => request({
                 method: "DELETE",
                 path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
-                query: { location: input["location"] },
                 successStatus: 204,
                 declaredStatuses: [400, 401],
                 empty: true,

package/dist/promise/generated/types.d.ts

@@ -3307,6 +3307,20 @@ export type IntegrationNotFoundError = {
     readonly message: string;
 };
 export declare const isIntegrationNotFoundError: (value: unknown) => value is IntegrationNotFoundError;
+export type IntegrationAttemptNotFoundError = {
+    readonly _tag: "IntegrationAttemptNotFoundError";
+    readonly integrationID: string;
+    readonly attemptID: string;
+    readonly message: string;
+};
+export declare const isIntegrationAttemptNotFoundError: (value: unknown) => value is IntegrationAttemptNotFoundError;
+export type IntegrationMethodNotFoundError = {
+    readonly _tag: "IntegrationMethodNotFoundError";
+    readonly integrationID: string;
+    readonly methodID: string;
+    readonly message: string;
+};
+export declare const isIntegrationMethodNotFoundError: (value: unknown) => value is IntegrationMethodNotFoundError;
 export type McpServerNotFoundError = {
     readonly _tag: "McpServerNotFoundError";
     readonly server: string;
@@ -5179,14 +5193,9 @@ export type SessionForkInput = {
     readonly sessionID: {
         readonly sessionID: string;
     }["sessionID"];
-    readonly boundary: {
-        readonly boundary: {
-            readonly type: "before";
-            readonly messageID: string;
-        } | {
-            readonly type: "through";
-        };
-    }["boundary"];
+    readonly before?: {
+        readonly before?: string | undefined;
+    }["before"];
 };
 export type SessionForkOutput = {
     data: SessionInfo;
@@ -6462,11 +6471,6 @@ export type CredentialUpdateInput = {
     readonly credentialID: {
         readonly credentialID: string;
     }["credentialID"];
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
     readonly label: {
         readonly label: string;
     }["label"];
@@ -6476,22 +6480,12 @@ export type CredentialActivateInput = {
     readonly credentialID: {
         readonly credentialID: string;
     }["credentialID"];
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
 };
 export type CredentialActivateOutput = void;
 export type CredentialRemoveInput = {
     readonly credentialID: {
         readonly credentialID: string;
     }["credentialID"];
-    readonly location?: {
-        readonly location?: {
-            readonly directory?: string | undefined;
-        } | undefined;
-    }["location"];
 };
 export type CredentialRemoveOutput = void;
 export type ProjectListOutput = Array<Project>;

package/dist/promise/generated/types.js

@@ -17,6 +17,8 @@ export const isInstructionEntryValueTooLargeError = (value) => typeof value ===
     value["_tag"] === "InstructionEntryValueTooLargeError";
 export const isProviderNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProviderNotFoundError";
 export const isIntegrationNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationNotFoundError";
+export const isIntegrationAttemptNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationAttemptNotFoundError";
+export const isIntegrationMethodNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationMethodNotFoundError";
 export const isMcpServerNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "McpServerNotFoundError";
 export const isProjectNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProjectNotFoundError";
 export const isFormNotFoundError = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormNotFoundError";

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/client",
-  "version": "0.0.0-dev-19574",
+  "version": "0.0.0-dev-19578",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -57,8 +57,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "0.0.0-dev-19574",
-    "@opencode/protocol": "0.0.0-dev-19574"
+    "@opencode/schema": "0.0.0-dev-19578",
+    "@opencode/protocol": "0.0.0-dev-19578"
   },
   "peerDependencies": {
     "effect": "4.0.0-rc.112",
@@ -74,7 +74,7 @@
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/httpapi-codegen": "0.0.0-dev-19574",
+    "@opencode/httpapi-codegen": "0.0.0-dev-19578",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",