sync

packages/opencode/src/lsp/server.ts

@@ -38,7 +38,9 @@ export namespace LSPServer {
             ? path.resolve(process.cwd(), process.argv0)
             : process.argv0
         return spawn(root, ["x", "typescript-language-server", "--stdio"], {
+          argv0: "bun",
           env: {
+            ...process.env,
             BUN_BE_BUN: "1",
           },
         })

packages/opencode/src/provider/provider.ts

@@ -23,6 +23,7 @@ import { WriteTool } from "../tool/write"
 import { TodoReadTool, TodoWriteTool } from "../tool/todo"
 import { AuthAnthropic } from "../auth/anthropic"
 import { ModelsDev } from "./models"
+import { NamedError } from "../util/error"
 
 export namespace Provider {
   const log = Log.create({ service: "provider" })
@@ -75,9 +76,18 @@ export namespace Provider {
     string,
     (provider: Info) => Promise<Record<string, any> | false>
   > = {
-    anthropic: async () => {
+    async anthropic(provider) {
       const access = await AuthAnthropic.access()
-      if (access)
+      if (access) {
+        // claude sub doesn't have usage cost
+        for (const model of Object.values(provider.models)) {
+          model.cost = {
+            input: 0,
+            inputCached: 0,
+            output: 0,
+            outputCached: 0,
+          }
+        }
         return {
           apiKey: "",
           headers: {
@@ -85,16 +95,15 @@ export namespace Provider {
             "anthropic-beta": "oauth-2025-04-20",
           },
         }
-      return env("ANTHROPIC_API_KEY")
+      }
+      return env("ANTHROPIC_API_KEY")(provider)
     },
     google: env("GOOGLE_GENERATIVE_AI_API_KEY"),
     openai: env("OPENAI_API_KEY"),
   }
 
   const state = App.state("provider", async () => {
-    log.info("loading config")
     const config = await Config.get()
-    log.info("loading providers")
     const database: Record<string, Provider.Info> = await ModelsDev.get()
 
     const providers: {
@@ -134,6 +143,10 @@ export namespace Provider {
       }
     }
 
+    for (const providerID of Object.keys(providers)) {
+      log.info("loaded", { providerID })
+    }
+
     return {
       models,
       providers,
@@ -148,28 +161,32 @@ export namespace Provider {
   }
 
   async function getSDK(providerID: string) {
-    const s = await state()
-    if (s.sdk.has(providerID)) return s.sdk.get(providerID)!
-
-    const dir = path.join(
-      Global.Path.cache,
-      `node_modules`,
-      `@ai-sdk`,
-      providerID,
-    )
-    if (!(await Bun.file(path.join(dir, "package.json")).exists())) {
-      log.info("installing", {
+    return (async () => {
+      const s = await state()
+      const existing = s.sdk.get(providerID)
+      if (existing) return existing
+      const dir = path.join(
+        Global.Path.cache,
+        `node_modules`,
+        `@ai-sdk`,
         providerID,
-      })
-      await BunProc.run(["add", `@ai-sdk/${providerID}@alpha`], {
-        cwd: Global.Path.cache,
-      })
-    }
-    const mod = await import(path.join(dir))
-    const fn = mod[Object.keys(mod).find((key) => key.startsWith("create"))!]
-    const loaded = fn(s.providers[providerID]?.options)
-    s.sdk.set(providerID, loaded)
-    return loaded as SDK
+      )
+      if (!(await Bun.file(path.join(dir, "package.json")).exists())) {
+        log.info("installing", {
+          providerID,
+        })
+        await BunProc.run(["add", `@ai-sdk/${providerID}@alpha`], {
+          cwd: Global.Path.cache,
+        })
+      }
+      const mod = await import(path.join(dir))
+      const fn = mod[Object.keys(mod).find((key) => key.startsWith("create"))!]
+      const loaded = fn(s.providers[providerID]?.options)
+      s.sdk.set(providerID, loaded)
+      return loaded as SDK
+    })().catch((e) => {
+      throw new InitError({ providerID: providerID }, { cause: e })
+    })
   }
 
   export async function getModel(providerID: string, modelID: string) {
@@ -183,12 +200,11 @@ export namespace Provider {
     })
 
     const provider = s.providers[providerID]
-    if (!provider) throw new ModelNotFoundError(modelID)
+    if (!provider) throw new ModelNotFoundError({ providerID, modelID })
     const info = provider.info.models[modelID]
-    if (!info) throw new ModelNotFoundError(modelID)
+    if (!info) throw new ModelNotFoundError({ providerID, modelID })
 
     const sdk = await getSDK(providerID)
-    if (!sdk) throw new ModelNotFoundError(modelID)
 
     try {
       const language = sdk.languageModel(modelID)
@@ -202,7 +218,14 @@ export namespace Provider {
         language,
       }
     } catch (e) {
-      if (e instanceof NoSuchModelError) throw new ModelNotFoundError(modelID)
+      if (e instanceof NoSuchModelError)
+        throw new ModelNotFoundError(
+          {
+            modelID: modelID,
+            providerID,
+          },
+          { cause: e },
+        )
       throw e
     }
   }
@@ -259,9 +282,26 @@ export namespace Provider {
     return TOOL_MAPPING[providerID] ?? TOOLS
   }
 
-  class ModelNotFoundError extends Error {
-    constructor(public readonly model: string) {
-      super()
-    }
-  }
+  export const ModelNotFoundError = NamedError.create(
+    "ProviderModelNotFoundError",
+    z.object({
+      providerID: z.string(),
+      modelID: z.string(),
+    }),
+  )
+
+  export const InitError = NamedError.create(
+    "ProviderInitError",
+    z.object({
+      providerID: z.string(),
+    }),
+  )
+
+  export const AuthError = NamedError.create(
+    "ProviderAuthError",
+    z.object({
+      providerID: z.string(),
+      message: z.string(),
+    }),
+  )
 }

packages/opencode/src/server/server.ts

@@ -11,6 +11,26 @@ import { Provider } from "../provider/provider"
 import { App } from "../app/app"
 import { Global } from "../global"
 import { mapValues } from "remeda"
+import { NamedError } from "../util/error"
+
+const ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z
+            .object({
+              data: z.record(z.string(), z.any()),
+            })
+            .openapi({
+              ref: "Error",
+            }),
+        ),
+      },
+    },
+  },
+} as const
 
 export namespace Server {
   const log = Log.create({ service: "server" })
@@ -22,13 +42,15 @@ export namespace Server {
 
     const result = app
       .onError((err, c) => {
-        log.error("error", err)
+        if (err instanceof NamedError) {
+          return c.json(err.toObject(), {
+            status: 400,
+          })
+        }
         return c.json(
+          new NamedError.Unknown({ message: err.toString() }).toObject(),
           {
-            error: err.toString(),
-          },
-          {
-            status: 500,
+            status: 400,
           },
         )
       })
@@ -197,6 +219,7 @@ export namespace Server {
         describeRoute({
           description: "Create a new session",
           responses: {
+            ...ERRORS,
             200: {
               description: "Successfully created session",
               content: {

packages/opencode/src/session/index.ts

@@ -6,6 +6,7 @@ import { Log } from "../util/log"
 import {
   convertToModelMessages,
   generateText,
+  LoadAPIKeyError,
   stepCountIs,
   streamText,
   tool,
@@ -28,6 +29,7 @@ import { Provider } from "../provider/provider"
 import { SessionContext } from "./context"
 import { ListTool } from "../tool/ls"
 import { MCP } from "../mcp"
+import { NamedError } from "../util/error"
 
 export namespace Session {
   const log = Log.create({ service: "session" })
@@ -59,6 +61,12 @@ export namespace Session {
         info: Info,
       }),
     ),
+    Error: Bus.event(
+      "session.error",
+      z.object({
+        error: Message.Info.shape.metadata.shape.error,
+      }),
+    ),
   }
 
   const state = App.state("session", () => {
@@ -296,11 +304,13 @@ export namespace Session {
           },
         ]),
         model: model.language,
-      }).then((result) => {
-        return Session.update(input.sessionID, (draft) => {
-          draft.title = result.text
-        })
       })
+        .then((result) => {
+          return Session.update(input.sessionID, (draft) => {
+            draft.title = result.text
+          })
+        })
+        .catch(() => {})
       await updateMessage(system)
     }
     const msg: Message.Info = {
@@ -506,11 +516,27 @@ export namespace Session {
         assistant.cost = usage.cost
         await updateMessage(next)
       },
-      onError(input) {
-        log.error("error", input)
-        if (input.error instanceof Error) {
-          next.metadata.error = input.error.toString()
+      onError(err) {
+        log.error("error", err)
+        switch (true) {
+          case LoadAPIKeyError.isInstance(err.error):
+            next.metadata.error = new Provider.AuthError(
+              {
+                providerID: input.providerID,
+                message: err.error.message,
+              },
+              { cause: err.error },
+            ).toObject()
+            break
+          case err.error instanceof Error:
+            next.metadata.error = new NamedError.Unknown(
+              { message: err.error.toString() },
+              { cause: err.error },
+            ).toObject()
         }
+        Bus.publish(Event.Error, {
+          error: next.metadata.error,
+        })
       },
       async prepareStep(step) {
         next.parts.push({
@@ -532,7 +558,7 @@ export namespace Session {
     })
     await result.consumeStream({
       onError: (err) => {
-        log.error("error", {
+        log.error("stream error", {
           err,
         })
       },

packages/opencode/src/session/message.ts

@@ -1,5 +1,7 @@
 import z from "zod"
 import { Bus } from "../bus"
+import { Provider } from "../provider/provider"
+import { NamedError } from "../util/error"
 
 export namespace Message {
   export const ToolCall = z
@@ -138,7 +140,10 @@ export namespace Message {
           created: z.number(),
           completed: z.number().optional(),
         }),
-        error: z.string().optional(),
+        error: z.discriminatedUnion("name", [
+          Provider.AuthError.Schema,
+          NamedError.Unknown.Schema,
+        ]),
         sessionID: z.string(),
         tool: z.record(z.string(), z.any()),
         assistant: z

packages/opencode/src/util/error.ts

@@ -0,0 +1,53 @@
+import { z, type ZodSchema } from "zod"
+
+export abstract class NamedError extends Error {
+  abstract schema(): ZodSchema
+  abstract toObject(): { name: string; data: any }
+
+  static create<Name extends string, Data extends ZodSchema>(
+    name: Name,
+    data: Data,
+  ) {
+    const result = class extends NamedError {
+      public static readonly Schema = z
+        .object({
+          name: z.literal(name),
+          data: data,
+        })
+        .openapi({
+          ref: name,
+        })
+
+      constructor(
+        public readonly data: z.input<Data>,
+        options?: ErrorOptions,
+      ) {
+        super(name, options)
+        this.name = name
+      }
+
+      static isInstance(input: any): input is InstanceType<typeof result> {
+        return "name" in input && input.name === name
+      }
+
+      schema() {
+        return data
+      }
+
+      toObject() {
+        return {
+          name: name,
+          data: this.data,
+        }
+      }
+    }
+    return result
+  }
+
+  public static readonly Unknown = NamedError.create(
+    "UnknownError",
+    z.object({
+      message: z.string(),
+    }),
+  )
+}

packages/tui/pkg/client/gen/openapi.json

@@ -158,6 +158,16 @@
                 }
               }
             }
+          },
+          "400": {
+            "description": "Bad request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Error"
+                }
+              }
+            }
           }
         },
         "operationId": "postSession_create",
@@ -439,30 +449,34 @@
             "$ref": "#/components/schemas/Event.storage.write"
           },
           {
-            "$ref": "#/components/schemas/Event.message.updated"
+            "$ref": "#/components/schemas/Event.lsp.client.diagnostics"
           },
           {
-            "$ref": "#/components/schemas/Event.message.part.updated"
+            "$ref": "#/components/schemas/Event.permission.updated"
           },
           {
-            "$ref": "#/components/schemas/Event.lsp.client.diagnostics"
+            "$ref": "#/components/schemas/Event.message.updated"
           },
           {
-            "$ref": "#/components/schemas/Event.permission.updated"
+            "$ref": "#/components/schemas/Event.message.part.updated"
           },
           {
             "$ref": "#/components/schemas/Event.session.updated"
+          },
+          {
+            "$ref": "#/components/schemas/Event.session.error"
           }
         ],
         "discriminator": {
           "propertyName": "type",
           "mapping": {
             "storage.write": "#/components/schemas/Event.storage.write",
-            "message.updated": "#/components/schemas/Event.message.updated",
-            "message.part.updated": "#/components/schemas/Event.message.part.updated",
             "lsp.client.diagnostics": "#/components/schemas/Event.lsp.client.diagnostics",
             "permission.updated": "#/components/schemas/Event.permission.updated",
-            "session.updated": "#/components/schemas/Event.session.updated"
+            "message.updated": "#/components/schemas/Event.message.updated",
+            "message.part.updated": "#/components/schemas/Event.message.part.updated",
+            "session.updated": "#/components/schemas/Event.session.updated",
+            "session.error": "#/components/schemas/Event.session.error"
           }
         }
       },
@@ -491,6 +505,86 @@
           "properties"
         ]
       },
+      "Event.lsp.client.diagnostics": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "lsp.client.diagnostics"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "serverID": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "serverID",
+              "path"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "Event.permission.updated": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "permission.updated"
+          },
+          "properties": {
+            "$ref": "#/components/schemas/permission.info"
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
+      "permission.info": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "sessionID": {
+            "type": "string"
+          },
+          "title": {
+            "type": "string"
+          },
+          "metadata": {
+            "type": "object",
+            "additionalProperties": {}
+          },
+          "time": {
+            "type": "object",
+            "properties": {
+              "created": {
+                "type": "number"
+              }
+            },
+            "required": [
+              "created"
+            ]
+          }
+        },
+        "required": [
+          "id",
+          "sessionID",
+          "title",
+          "metadata",
+          "time"
+        ]
+      },
       "Event.message.updated": {
         "type": "object",
         "properties": {
@@ -553,7 +647,21 @@
                 ]
               },
               "error": {
-                "type": "string"
+                "oneOf": [
+                  {
+                    "$ref": "#/components/schemas/ProviderAuthError"
+                  },
+                  {
+                    "$ref": "#/components/schemas/UnknownError"
+                  }
+                ],
+                "discriminator": {
+                  "propertyName": "name",
+                  "mapping": {
+                    "ProviderAuthError": "#/components/schemas/ProviderAuthError",
+                    "UnknownError": "#/components/schemas/UnknownError"
+                  }
+                }
               },
               "sessionID": {
                 "type": "string"
@@ -607,6 +715,7 @@
             },
             "required": [
               "time",
+              "error",
               "sessionID",
               "tool"
             ]
@@ -863,108 +972,80 @@
           "type"
         ]
       },
-      "Event.message.part.updated": {
+      "ProviderAuthError": {
         "type": "object",
         "properties": {
-          "type": {
+          "name": {
             "type": "string",
-            "const": "message.part.updated"
+            "const": "ProviderAuthError"
           },
-          "properties": {
+          "data": {
             "type": "object",
             "properties": {
-              "part": {
-                "$ref": "#/components/schemas/Message.Part"
+              "providerID": {
+                "type": "string"
+              },
+              "message": {
+                "type": "string"
               }
             },
             "required": [
-              "part"
+              "providerID",
+              "message"
             ]
           }
         },
         "required": [
-          "type",
-          "properties"
+          "name",
+          "data"
         ]
       },
-      "Event.lsp.client.diagnostics": {
+      "UnknownError": {
         "type": "object",
         "properties": {
-          "type": {
+          "name": {
             "type": "string",
-            "const": "lsp.client.diagnostics"
+            "const": "UnknownError"
           },
-          "properties": {
+          "data": {
             "type": "object",
             "properties": {
-              "serverID": {
-                "type": "string"
-              },
-              "path": {
+              "message": {
                 "type": "string"
               }
             },
             "required": [
-              "serverID",
-              "path"
+              "message"
             ]
           }
         },
         "required": [
-          "type",
-          "properties"
+          "name",
+          "data"
         ]
       },
-      "Event.permission.updated": {
+      "Event.message.part.updated": {
         "type": "object",
         "properties": {
           "type": {
             "type": "string",
-            "const": "permission.updated"
+            "const": "message.part.updated"
           },
           "properties": {
-            "$ref": "#/components/schemas/permission.info"
-          }
-        },
-        "required": [
-          "type",
-          "properties"
-        ]
-      },
-      "permission.info": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "sessionID": {
-            "type": "string"
-          },
-          "title": {
-            "type": "string"
-          },
-          "metadata": {
-            "type": "object",
-            "additionalProperties": {}
-          },
-          "time": {
             "type": "object",
             "properties": {
-              "created": {
-                "type": "number"
+              "part": {
+                "$ref": "#/components/schemas/Message.Part"
               }
             },
             "required": [
-              "created"
+              "part"
             ]
           }
         },
         "required": [
-          "id",
-          "sessionID",
-          "title",
-          "metadata",
-          "time"
+          "type",
+          "properties"
         ]
       },
       "Event.session.updated": {
@@ -1038,6 +1119,44 @@
           "time"
         ]
       },
+      "Event.session.error": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "const": "session.error"
+          },
+          "properties": {
+            "type": "object",
+            "properties": {
+              "error": {
+                "oneOf": [
+                  {
+                    "$ref": "#/components/schemas/ProviderAuthError"
+                  },
+                  {
+                    "$ref": "#/components/schemas/UnknownError"
+                  }
+                ],
+                "discriminator": {
+                  "propertyName": "name",
+                  "mapping": {
+                    "ProviderAuthError": "#/components/schemas/ProviderAuthError",
+                    "UnknownError": "#/components/schemas/UnknownError"
+                  }
+                }
+              }
+            },
+            "required": [
+              "error"
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "properties"
+        ]
+      },
       "App.Info": {
         "type": "object",
         "properties": {
@@ -1086,6 +1205,18 @@
           "time"
         ]
       },
+      "Error": {
+        "type": "object",
+        "properties": {
+          "data": {
+            "type": "object",
+            "additionalProperties": {}
+          }
+        },
+        "required": [
+          "data"
+        ]
+      },
       "Provider.Info": {
         "type": "object",
         "properties": {

packages/tui/pkg/client/generated-client.go

@@ -39,6 +39,11 @@ type AppInfo struct {
 	User string `json:"user"`
 }
 
+// Error defines model for Error.
+type Error struct {
+	Data map[string]interface{} `json:"data"`
+}
+
 // Event defines model for Event.
 type Event struct {
 	union json.RawMessage
@@ -75,6 +80,19 @@ type EventPermissionUpdated struct {
 	Type       string         `json:"type"`
 }
 
+// EventSessionError defines model for Event.session.error.
+type EventSessionError struct {
+	Properties struct {
+		Error EventSessionError_Properties_Error `json:"error"`
+	} `json:"properties"`
+	Type string `json:"type"`
+}
+
+// EventSessionError_Properties_Error defines model for EventSessionError.Properties.Error.
+type EventSessionError_Properties_Error struct {
+	union json.RawMessage
+}
+
 // EventSessionUpdated defines model for Event.session.updated.
 type EventSessionUpdated struct {
 	Properties struct {
@@ -107,8 +125,8 @@ type MessageInfo struct {
 				Reasoning float32 `json:"reasoning"`
 			} `json:"tokens"`
 		} `json:"assistant,omitempty"`
-		Error     *string `json:"error,omitempty"`
-		SessionID string  `json:"sessionID"`
+		Error     MessageInfo_Metadata_Error `json:"error"`
+		SessionID string                     `json:"sessionID"`
 		Time      struct {
 			Completed *float32 `json:"completed,omitempty"`
 			Created   float32  `json:"created"`
@@ -119,6 +137,11 @@ type MessageInfo struct {
 	Role  MessageInfoRole `json:"role"`
 }
 
+// MessageInfo_Metadata_Error defines model for MessageInfo.Metadata.Error.
+type MessageInfo_Metadata_Error struct {
+	union json.RawMessage
+}
+
 // MessageInfoRole defines model for MessageInfo.Role.
 type MessageInfoRole string
 
@@ -226,6 +249,23 @@ type ProviderModel struct {
 	Reasoning *bool   `json:"reasoning,omitempty"`
 }
 
+// ProviderAuthError defines model for ProviderAuthError.
+type ProviderAuthError struct {
+	Data struct {
+		Message    string `json:"message"`
+		ProviderID string `json:"providerID"`
+	} `json:"data"`
+	Name string `json:"name"`
+}
+
+// UnknownError defines model for UnknownError.
+type UnknownError struct {
+	Data struct {
+		Message string `json:"message"`
+	} `json:"data"`
+	Name string `json:"name"`
+}
+
 // PermissionInfo defines model for permission.info.
 type PermissionInfo struct {
 	Id        string                 `json:"id"`
@@ -334,24 +374,24 @@ func (t *Event) MergeEventStorageWrite(v EventStorageWrite) error {
 	return err
 }
 
-// AsEventMessageUpdated returns the union data inside the Event as a EventMessageUpdated
-func (t Event) AsEventMessageUpdated() (EventMessageUpdated, error) {
-	var body EventMessageUpdated
+// AsEventLspClientDiagnostics returns the union data inside the Event as a EventLspClientDiagnostics
+func (t Event) AsEventLspClientDiagnostics() (EventLspClientDiagnostics, error) {
+	var body EventLspClientDiagnostics
 	err := json.Unmarshal(t.union, &body)
 	return body, err
 }
 
-// FromEventMessageUpdated overwrites any union data inside the Event as the provided EventMessageUpdated
-func (t *Event) FromEventMessageUpdated(v EventMessageUpdated) error {
-	v.Type = "message.updated"
+// FromEventLspClientDiagnostics overwrites any union data inside the Event as the provided EventLspClientDiagnostics
+func (t *Event) FromEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
+	v.Type = "lsp.client.diagnostics"
 	b, err := json.Marshal(v)
 	t.union = b
 	return err
 }
 
-// MergeEventMessageUpdated performs a merge with any union data inside the Event, using the provided EventMessageUpdated
-func (t *Event) MergeEventMessageUpdated(v EventMessageUpdated) error {
-	v.Type = "message.updated"
+// MergeEventLspClientDiagnostics performs a merge with any union data inside the Event, using the provided EventLspClientDiagnostics
+func (t *Event) MergeEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
+	v.Type = "lsp.client.diagnostics"
 	b, err := json.Marshal(v)
 	if err != nil {
 		return err
@@ -362,24 +402,24 @@ func (t *Event) MergeEventMessageUpdated(v EventMessageUpdated) error {
 	return err
 }
 
-// AsEventMessagePartUpdated returns the union data inside the Event as a EventMessagePartUpdated
-func (t Event) AsEventMessagePartUpdated() (EventMessagePartUpdated, error) {
-	var body EventMessagePartUpdated
+// AsEventPermissionUpdated returns the union data inside the Event as a EventPermissionUpdated
+func (t Event) AsEventPermissionUpdated() (EventPermissionUpdated, error) {
+	var body EventPermissionUpdated
 	err := json.Unmarshal(t.union, &body)
 	return body, err
 }
 
-// FromEventMessagePartUpdated overwrites any union data inside the Event as the provided EventMessagePartUpdated
-func (t *Event) FromEventMessagePartUpdated(v EventMessagePartUpdated) error {
-	v.Type = "message.part.updated"
+// FromEventPermissionUpdated overwrites any union data inside the Event as the provided EventPermissionUpdated
+func (t *Event) FromEventPermissionUpdated(v EventPermissionUpdated) error {
+	v.Type = "permission.updated"
 	b, err := json.Marshal(v)
 	t.union = b
 	return err
 }
 
-// MergeEventMessagePartUpdated performs a merge with any union data inside the Event, using the provided EventMessagePartUpdated
-func (t *Event) MergeEventMessagePartUpdated(v EventMessagePartUpdated) error {
-	v.Type = "message.part.updated"
+// MergeEventPermissionUpdated performs a merge with any union data inside the Event, using the provided EventPermissionUpdated
+func (t *Event) MergeEventPermissionUpdated(v EventPermissionUpdated) error {
+	v.Type = "permission.updated"
 	b, err := json.Marshal(v)
 	if err != nil {
 		return err
@@ -390,24 +430,24 @@ func (t *Event) MergeEventMessagePartUpdated(v EventMessagePartUpdated) error {
 	return err
 }
 
-// AsEventLspClientDiagnostics returns the union data inside the Event as a EventLspClientDiagnostics
-func (t Event) AsEventLspClientDiagnostics() (EventLspClientDiagnostics, error) {
-	var body EventLspClientDiagnostics
+// AsEventMessageUpdated returns the union data inside the Event as a EventMessageUpdated
+func (t Event) AsEventMessageUpdated() (EventMessageUpdated, error) {
+	var body EventMessageUpdated
 	err := json.Unmarshal(t.union, &body)
 	return body, err
 }
 
-// FromEventLspClientDiagnostics overwrites any union data inside the Event as the provided EventLspClientDiagnostics
-func (t *Event) FromEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
-	v.Type = "lsp.client.diagnostics"
+// FromEventMessageUpdated overwrites any union data inside the Event as the provided EventMessageUpdated
+func (t *Event) FromEventMessageUpdated(v EventMessageUpdated) error {
+	v.Type = "message.updated"
 	b, err := json.Marshal(v)
 	t.union = b
 	return err
 }
 
-// MergeEventLspClientDiagnostics performs a merge with any union data inside the Event, using the provided EventLspClientDiagnostics
-func (t *Event) MergeEventLspClientDiagnostics(v EventLspClientDiagnostics) error {
-	v.Type = "lsp.client.diagnostics"
+// MergeEventMessageUpdated performs a merge with any union data inside the Event, using the provided EventMessageUpdated
+func (t *Event) MergeEventMessageUpdated(v EventMessageUpdated) error {
+	v.Type = "message.updated"
 	b, err := json.Marshal(v)
 	if err != nil {
 		return err
@@ -418,24 +458,24 @@ func (t *Event) MergeEventLspClientDiagnostics(v EventLspClientDiagnostics) erro
 	return err
 }
 
-// AsEventPermissionUpdated returns the union data inside the Event as a EventPermissionUpdated
-func (t Event) AsEventPermissionUpdated() (EventPermissionUpdated, error) {
-	var body EventPermissionUpdated
+// AsEventMessagePartUpdated returns the union data inside the Event as a EventMessagePartUpdated
+func (t Event) AsEventMessagePartUpdated() (EventMessagePartUpdated, error) {
+	var body EventMessagePartUpdated
 	err := json.Unmarshal(t.union, &body)
 	return body, err
 }
 
-// FromEventPermissionUpdated overwrites any union data inside the Event as the provided EventPermissionUpdated
-func (t *Event) FromEventPermissionUpdated(v EventPermissionUpdated) error {
-	v.Type = "permission.updated"
+// FromEventMessagePartUpdated overwrites any union data inside the Event as the provided EventMessagePartUpdated
+func (t *Event) FromEventMessagePartUpdated(v EventMessagePartUpdated) error {
+	v.Type = "message.part.updated"
 	b, err := json.Marshal(v)
 	t.union = b
 	return err
 }
 
-// MergeEventPermissionUpdated performs a merge with any union data inside the Event, using the provided EventPermissionUpdated
-func (t *Event) MergeEventPermissionUpdated(v EventPermissionUpdated) error {
-	v.Type = "permission.updated"
+// MergeEventMessagePartUpdated performs a merge with any union data inside the Event, using the provided EventMessagePartUpdated
+func (t *Event) MergeEventMessagePartUpdated(v EventMessagePartUpdated) error {
+	v.Type = "message.part.updated"
 	b, err := json.Marshal(v)
 	if err != nil {
 		return err
@@ -474,6 +514,34 @@ func (t *Event) MergeEventSessionUpdated(v EventSessionUpdated) error {
 	return err
 }
 
+// AsEventSessionError returns the union data inside the Event as a EventSessionError
+func (t Event) AsEventSessionError() (EventSessionError, error) {
+	var body EventSessionError
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromEventSessionError overwrites any union data inside the Event as the provided EventSessionError
+func (t *Event) FromEventSessionError(v EventSessionError) error {
+	v.Type = "session.error"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeEventSessionError performs a merge with any union data inside the Event, using the provided EventSessionError
+func (t *Event) MergeEventSessionError(v EventSessionError) error {
+	v.Type = "session.error"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
 func (t Event) Discriminator() (string, error) {
 	var discriminator struct {
 		Discriminator string `json:"type"`
@@ -496,6 +564,8 @@ func (t Event) ValueByDiscriminator() (interface{}, error) {
 		return t.AsEventMessageUpdated()
 	case "permission.updated":
 		return t.AsEventPermissionUpdated()
+	case "session.error":
+		return t.AsEventSessionError()
 	case "session.updated":
 		return t.AsEventSessionUpdated()
 	case "storage.write":
@@ -515,6 +585,184 @@ func (t *Event) UnmarshalJSON(b []byte) error {
 	return err
 }
 
+// AsProviderAuthError returns the union data inside the EventSessionError_Properties_Error as a ProviderAuthError
+func (t EventSessionError_Properties_Error) AsProviderAuthError() (ProviderAuthError, error) {
+	var body ProviderAuthError
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromProviderAuthError overwrites any union data inside the EventSessionError_Properties_Error as the provided ProviderAuthError
+func (t *EventSessionError_Properties_Error) FromProviderAuthError(v ProviderAuthError) error {
+	v.Name = "ProviderAuthError"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeProviderAuthError performs a merge with any union data inside the EventSessionError_Properties_Error, using the provided ProviderAuthError
+func (t *EventSessionError_Properties_Error) MergeProviderAuthError(v ProviderAuthError) error {
+	v.Name = "ProviderAuthError"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsUnknownError returns the union data inside the EventSessionError_Properties_Error as a UnknownError
+func (t EventSessionError_Properties_Error) AsUnknownError() (UnknownError, error) {
+	var body UnknownError
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromUnknownError overwrites any union data inside the EventSessionError_Properties_Error as the provided UnknownError
+func (t *EventSessionError_Properties_Error) FromUnknownError(v UnknownError) error {
+	v.Name = "UnknownError"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeUnknownError performs a merge with any union data inside the EventSessionError_Properties_Error, using the provided UnknownError
+func (t *EventSessionError_Properties_Error) MergeUnknownError(v UnknownError) error {
+	v.Name = "UnknownError"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t EventSessionError_Properties_Error) Discriminator() (string, error) {
+	var discriminator struct {
+		Discriminator string `json:"name"`
+	}
+	err := json.Unmarshal(t.union, &discriminator)
+	return discriminator.Discriminator, err
+}
+
+func (t EventSessionError_Properties_Error) ValueByDiscriminator() (interface{}, error) {
+	discriminator, err := t.Discriminator()
+	if err != nil {
+		return nil, err
+	}
+	switch discriminator {
+	case "ProviderAuthError":
+		return t.AsProviderAuthError()
+	case "UnknownError":
+		return t.AsUnknownError()
+	default:
+		return nil, errors.New("unknown discriminator value: " + discriminator)
+	}
+}
+
+func (t EventSessionError_Properties_Error) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *EventSessionError_Properties_Error) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
+// AsProviderAuthError returns the union data inside the MessageInfo_Metadata_Error as a ProviderAuthError
+func (t MessageInfo_Metadata_Error) AsProviderAuthError() (ProviderAuthError, error) {
+	var body ProviderAuthError
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromProviderAuthError overwrites any union data inside the MessageInfo_Metadata_Error as the provided ProviderAuthError
+func (t *MessageInfo_Metadata_Error) FromProviderAuthError(v ProviderAuthError) error {
+	v.Name = "ProviderAuthError"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeProviderAuthError performs a merge with any union data inside the MessageInfo_Metadata_Error, using the provided ProviderAuthError
+func (t *MessageInfo_Metadata_Error) MergeProviderAuthError(v ProviderAuthError) error {
+	v.Name = "ProviderAuthError"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+// AsUnknownError returns the union data inside the MessageInfo_Metadata_Error as a UnknownError
+func (t MessageInfo_Metadata_Error) AsUnknownError() (UnknownError, error) {
+	var body UnknownError
+	err := json.Unmarshal(t.union, &body)
+	return body, err
+}
+
+// FromUnknownError overwrites any union data inside the MessageInfo_Metadata_Error as the provided UnknownError
+func (t *MessageInfo_Metadata_Error) FromUnknownError(v UnknownError) error {
+	v.Name = "UnknownError"
+	b, err := json.Marshal(v)
+	t.union = b
+	return err
+}
+
+// MergeUnknownError performs a merge with any union data inside the MessageInfo_Metadata_Error, using the provided UnknownError
+func (t *MessageInfo_Metadata_Error) MergeUnknownError(v UnknownError) error {
+	v.Name = "UnknownError"
+	b, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+
+	merged, err := runtime.JSONMerge(t.union, b)
+	t.union = merged
+	return err
+}
+
+func (t MessageInfo_Metadata_Error) Discriminator() (string, error) {
+	var discriminator struct {
+		Discriminator string `json:"name"`
+	}
+	err := json.Unmarshal(t.union, &discriminator)
+	return discriminator.Discriminator, err
+}
+
+func (t MessageInfo_Metadata_Error) ValueByDiscriminator() (interface{}, error) {
+	discriminator, err := t.Discriminator()
+	if err != nil {
+		return nil, err
+	}
+	switch discriminator {
+	case "ProviderAuthError":
+		return t.AsProviderAuthError()
+	case "UnknownError":
+		return t.AsUnknownError()
+	default:
+		return nil, errors.New("unknown discriminator value: " + discriminator)
+	}
+}
+
+func (t MessageInfo_Metadata_Error) MarshalJSON() ([]byte, error) {
+	b, err := t.union.MarshalJSON()
+	return b, err
+}
+
+func (t *MessageInfo_Metadata_Error) UnmarshalJSON(b []byte) error {
+	err := t.union.UnmarshalJSON(b)
+	return err
+}
+
 // AsMessagePartText returns the union data inside the MessagePart as a MessagePartText
 func (t MessagePart) AsMessagePartText() (MessagePartText, error) {
 	var body MessagePartText
@@ -1886,6 +2134,7 @@ type PostSessionCreateResponse struct {
 	Body         []byte
 	HTTPResponse *http.Response
 	JSON200      *SessionInfo
+	JSON400      *Error
 }
 
 // Status returns HTTPResponse.Status
@@ -2390,6 +2639,13 @@ func ParsePostSessionCreateResponse(rsp *http.Response) (*PostSessionCreateRespo
 		}
 		response.JSON200 = &dest
 
+	case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400:
+		var dest Error
+		if err := json.Unmarshal(bodyBytes, &dest); err != nil {
+			return nil, err
+		}
+		response.JSON400 = &dest
+
 	}
 
 	return response, nil