openAgent

1import { isRecord } from "./record"
2 
3type ConfigIssue = { message: string; path: string[] }
4 
5export function cliErrorMessage(input: unknown): string | undefined {
6  if (input instanceof Error && isRecord(input.cause) && "body" in input.cause) {
7    const formatted = cliErrorMessage(input.cause.body)
8    if (formatted) return formatted
9  }
10 
11  if (tagged(input, "CliError")) {
12    if (typeof input.exitCode === "number") process.exitCode = input.exitCode
13    return field(input, "message") ?? ""
14  }
15  if (tagged(input, "AccountServiceError") || tagged(input, "AccountTransportError")) {
16    return field(input, "message") ?? ""
17  }
18 
19  const model = configData(input, "ProviderModelNotFoundError")
20  if (model) {
21    const suggestions = Array.isArray(model.suggestions)
22      ? model.suggestions.filter((item): item is string => typeof item === "string")
23      : []
24    return [
25      `Model not found: ${field(model, "providerID")}/${field(model, "modelID")}`,
26      ...(suggestions.length ? ["Did you mean: " + suggestions.join(", ")] : []),
27      "Try: `opencode models` to list available models",
28      "Or check your config (opencode.json) provider/model names",
29    ].join("\n")
30  }
31 
32  const provider = configData(input, "ProviderInitError")
33  if (provider)
34    return `Failed to initialize provider "${field(provider, "providerID")}". Check credentials and configuration.`
35 
36  const json = configData(input, "ConfigJsonError")
37  if (json) {
38    const message = field(json, "message")
39    return `Config file at ${field(json, "path")} is not valid JSON(C)` + (message ? `: ${message}` : "")
40  }
41 
42  const directory = configData(input, "ConfigDirectoryTypoError")
43  if (directory) {
44    return `Directory "${field(directory, "dir")}" in ${field(directory, "path")} is not valid. Rename the directory to "${field(directory, "suggestion")}" or remove it. This is a common typo.`
45  }
46 
47  const frontmatter = configData(input, "ConfigFrontmatterError")
48  if (frontmatter) return field(frontmatter, "message") ?? ""
49 
50  const invalid = configData(input, "ConfigInvalidError")
51  if (invalid) {
52    const path = field(invalid, "path")
53    const message = field(invalid, "message")
54    const issues = Array.isArray(invalid.issues)
55      ? invalid.issues.filter((issue): issue is ConfigIssue => {
56          return (
57            isRecord(issue) &&
58            typeof issue.message === "string" &&
59            Array.isArray(issue.path) &&
60            issue.path.every((item) => typeof item === "string")
61          )
62        })
63      : []
64    return [
65      `Configuration is invalid${path && path !== "config" ? ` at ${path}` : ""}` + (message ? `: ${message}` : ""),
66      ...issues.map((issue) => "↳ " + issue.message + " " + issue.path.join(".")),
67    ].join("\n")
68  }
69 
70  if (tagged(input, "UICancelledError") || named(input, "UICancelledError")) return ""
71  if (isRecord(input) && named(input, "MCPFailed")) {
72    const name = isRecord(input.data) ? field(input.data, "name") : undefined
73    return `MCP server "${name}" failed. Note, opencode does not support MCP authentication yet.`
74  }
75  return undefined
76}
77 
78function tagged(input: unknown, tag: string): input is Record<string, unknown> {
79  return isRecord(input) && input._tag === tag
80}
81 
82function named(input: unknown, name: string) {
83  return isRecord(input) && (input.name === name || input._tag === name)
84}
85 
86function configData(input: unknown, tag: string) {
87  if (!isRecord(input)) return undefined
88  if (input.name === tag && isRecord(input.data)) return input.data
89  if (input._tag === tag) return input
90  return undefined
91}
92 
93function field(input: Record<string, unknown>, key: string) {
94  return typeof input[key] === "string" ? input[key] : undefined
95}
96 
97export function errorFormat(error: unknown): string {
98  if (error instanceof Error) {
99    return error.stack ?? `${error.name}: ${error.message}`
100  }
101 
102  if (typeof error === "object" && error !== null) {
103    try {
104      const json = JSON.stringify(error, null, 2)
105      // Plain objects whose own properties are all non-enumerable (or empty)
106      // serialize to "{}", which prints as a useless bare `{}` on stderr.
107      // Fall back to a custom toString first, then to ctor name + own prop names.
108      if (json === "{}") {
109        const str = String(error)
110        if (str && str !== "[object Object]") return str
111        const ctor = error.constructor?.name
112        const prefix = ctor && ctor !== "Object" ? ctor : "Error"
113        const names = Object.getOwnPropertyNames(error)
114        return names.length === 0 ? `${prefix} (no message)` : `${prefix} { ${names.join(", ")} }`
115      }
116      return json
117    } catch {
118      return "Unexpected error (unserializable)"
119    }
120  }
121 
122  return String(error)
123}
124 
125export function errorMessage(error: unknown): string {
126  if (error instanceof Error) {
127    if (error.message) return error.message
128    if (error.name) return error.name
129  }
130 
131  if (isRecord(error) && typeof error.message === "string" && error.message) {
132    return error.message
133  }
134 
135  if (isRecord(error) && isRecord(error.data) && typeof error.data.message === "string" && error.data.message) {
136    return error.data.message
137  }
138 
139  const text = String(error)
140  if (text && text !== "[object Object]") return text
141 
142  const formatted = errorFormat(error)
143  if (formatted) return formatted
144  return "unknown error"
145}
146 
147export function errorData(error: unknown) {
148  if (error instanceof Error) {
149    return {
150      type: error.name,
151      message: errorMessage(error),
152      stack: error.stack,
153      cause: error.cause === undefined ? undefined : errorFormat(error.cause),
154      formatted: errorFormat(error),
155    }
156  }
157 
158  if (!isRecord(error)) {
159    return {
160      type: typeof error,
161      message: errorMessage(error),
162      formatted: errorFormat(error),
163    }
164  }
165 
166  const data = Object.getOwnPropertyNames(error).reduce<Record<string, unknown>>((acc, key) => {
167    const value = error[key]
168    if (value === undefined) return acc
169    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
170      acc[key] = value
171      return acc
172    }
173    // oxlint-disable-next-line no-base-to-string -- intentional coercion of arbitrary error properties
174    acc[key] = value instanceof Error ? value.message : String(value)
175    return acc
176  }, {})
177 
178  if (typeof data.message !== "string") data.message = errorMessage(error)
179  if (typeof data.type !== "string") data.type = error.constructor?.name
180  data.formatted = errorFormat(error)
181  return data
182}
183