aljaz/opencode
1
0
Fork 0
mirror of https://github.com/aljazceru/opencode.git synced 2025-12-28 21:24:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

sync

Browse Source
This commit is contained in:
Dax Raad
2025-06-09 14:01:11 -04:00
parent fa3253d1b6
commit 021fd3fcb5
8 changed files with 734 additions and 198 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
packages/opencode/src/lsp/server.ts
View File

@@ -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",
},
})

110
packages/opencode/src/provider/provider.ts
View File

@@ -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(),
}),
)
}

33
packages/opencode/src/server/server.ts
View File

@@ -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: {

44
packages/opencode/src/session/index.ts
View File

@@ -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,
})
},

7
packages/opencode/src/session/message.ts
View File

@@ -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

53
packages/opencode/src/util/error.ts Normal file
View File

@@ -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(),
}),
)
}

311
packages/tui/pkg/client/gen/openapi.json
View File

@@ -158,6 +158,16 @@
}
}
}
},
"400": {
"description": "Bad request",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Error"
}
}
}
}
},
"operationId": "postSession_create",
@@ -438,31 +448,35 @@
{
"$ref": "#/components/schemas/Event.storage.write"
},
{
"$ref": "#/components/schemas/Event.message.updated"
},
{
"$ref": "#/components/schemas/Event.message.part.updated"
},
{
"$ref": "#/components/schemas/Event.lsp.client.diagnostics"
},
{
"$ref": "#/components/schemas/Event.permission.updated"
},
{
"$ref": "#/components/schemas/Event.message.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,6 +972,58 @@
"type"
]
},
"ProviderAuthError": {
"type": "object",
"properties": {
"name": {
"type": "string",
"const": "ProviderAuthError"
},
"data": {
"type": "object",
"properties": {
"providerID": {
"type": "string"
},
"message": {
"type": "string"
}
},
"required": [
"providerID",
"message"
]
}
},
"required": [
"name",
"data"
]
},
"UnknownError": {
"type": "object",
"properties": {
"name": {
"type": "string",
"const": "UnknownError"
},
"data": {
"type": "object",
"properties": {
"message": {
"type": "string"
}
},
"required": [
"message"
]
}
},
"required": [
"name",
"data"
]
},
"Event.message.part.updated": {
"type": "object",
"properties": {
@@ -887,86 +1048,6 @@
"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.session.updated": {
"type": "object",
"properties": {
@@ -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": {

372
packages/tui/pkg/client/generated-client.go
View File

@@ -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,62 +374,6 @@ 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
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"
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"
b, err := json.Marshal(v)
if err != nil {
return err
}
merged, err := runtime.JSONMerge(t.union, b)
t.union = merged
return err
}
// 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
}
// 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
}
// 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
}
merged, err := runtime.JSONMerge(t.union, b)
t.union = merged
return err
}
// AsEventLspClientDiagnostics returns the union data inside the Event as a EventLspClientDiagnostics
func (t Event) AsEventLspClientDiagnostics() (EventLspClientDiagnostics, error) {
var body EventLspClientDiagnostics
@@ -446,6 +430,62 @@ func (t *Event) MergeEventPermissionUpdated(v EventPermissionUpdated) error {
return err
}
// 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
}
// 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
}
// 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
}
merged, err := runtime.JSONMerge(t.union, b)
t.union = merged
return err
}
// 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
}
// 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
}
// 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
}
merged, err := runtime.JSONMerge(t.union, b)
t.union = merged
return err
}
// AsEventSessionUpdated returns the union data inside the Event as a EventSessionUpdated
func (t Event) AsEventSessionUpdated() (EventSessionUpdated, error) {
var body EventSessionUpdated
@@ -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