opencode-translate 1.0.5 → 1.0.7

package/src/auth/oauth-fetch.ts

@@ -1,100 +0,0 @@
-import {
-  isAnthropicMessagesRequest,
-  rewriteMessagesBody,
-  rewriteMessagesURL,
-  setOAuthHeaders as setAnthropicOAuthHeaders,
-} from "../anthropic-oauth"
-import type { FetchLike, OAuthInfo } from "../constants"
-import { rewriteOpenAICodexBody } from "./codex-request"
-import { convertCodexSSEToJSON } from "./codex-response"
-import { copyHeaders, packageUserAgent, setUserAgent } from "./headers"
-import { exchangeCopilotToken } from "./refresh"
-import type { AuthRuntime, OAuthResolver } from "./types"
-
-interface OAuthFetchOptions extends AuthRuntime {
-  providerID: string
-  resolveOAuth: OAuthResolver
-  packageVersion?: string
-}
-
-interface RequestState {
-  headers: Headers
-  inputUrl: URL
-  body: BodyInit | null | undefined
-  convertCodexResponse: boolean
-}
-
-function applyAnthropicRequest(state: RequestState, info: OAuthInfo) {
-  setAnthropicOAuthHeaders(state.headers, info.access)
-  state.headers.set("anthropic-version", "2023-06-01")
-  rewriteMessagesURL(state.inputUrl)
-  if (isAnthropicMessagesRequest(state.inputUrl) && typeof state.body === "string") {
-    state.body = rewriteMessagesBody(state.body)
-  }
-}
-
-function applyOpenAIRequest(state: RequestState, info: OAuthInfo) {
-  state.headers.set("Authorization", `Bearer ${info.access}`)
-  if (info.accountId) state.headers.set("ChatGPT-Account-Id", info.accountId)
-  if (
-    state.inputUrl.hostname !== "api.openai.com" ||
-    (state.inputUrl.pathname !== "/v1/chat/completions" && state.inputUrl.pathname !== "/v1/responses")
-  ) {
-    return
-  }
-
-  const rewritten = rewriteOpenAICodexBody(state.body)
-  state.inputUrl.protocol = "https:"
-  state.inputUrl.hostname = "chatgpt.com"
-  state.inputUrl.pathname = "/backend-api/codex/responses"
-  state.inputUrl.search = ""
-  state.body = rewritten.body
-  state.convertCodexResponse = !rewritten.originalStream
-  state.headers.set("OpenAI-Beta", "responses=experimental")
-  state.headers.set("originator", "codex_cli_rs")
-  state.headers.set("accept", "text/event-stream")
-  state.headers.delete("content-length")
-}
-
-async function applyCopilotRequest(state: RequestState, info: OAuthInfo, options: OAuthFetchOptions) {
-  const session = await exchangeCopilotToken(info, options)
-  state.headers.set("Authorization", `Bearer ${session.token}`)
-  state.headers.set("Editor-Version", packageUserAgent(options.packageVersion))
-  state.headers.set("Editor-Plugin-Version", packageUserAgent(options.packageVersion))
-  state.headers.set("Copilot-Integration-Id", "vscode-chat")
-  state.headers.delete("x-api-key")
-
-  if (info.enterpriseUrl) {
-    const target = new URL(info.enterpriseUrl.includes("://") ? info.enterpriseUrl : `https://${info.enterpriseUrl}`)
-    state.inputUrl.protocol = target.protocol
-    state.inputUrl.hostname = target.hostname
-    state.inputUrl.port = target.port
-  }
-}
-
-function inputToURL(input: RequestInfo | URL): URL {
-  return input instanceof URL ? new URL(input.href) : new URL(typeof input === "string" ? input : input.url)
-}
-
-export function buildOAuthFetch(options: OAuthFetchOptions): FetchLike {
-  return async (input, init) => {
-    const info = await options.resolveOAuth(options.providerID)
-    if (!info) return options.fetchImpl(input, init)
-
-    const state: RequestState = {
-      headers: copyHeaders(init?.headers),
-      inputUrl: inputToURL(input),
-      body: init?.body,
-      convertCodexResponse: false,
-    }
-    setUserAgent(state.headers, options.packageVersion)
-
-    if (options.providerID === "anthropic") applyAnthropicRequest(state, info)
-    if (options.providerID === "openai") applyOpenAIRequest(state, info)
-    if (options.providerID === "github-copilot") await applyCopilotRequest(state, info, options)
-
-    const response = await options.fetchImpl(state.inputUrl, { ...init, headers: state.headers, body: state.body })
-    if (state.convertCodexResponse && response.ok) return convertCodexSSEToJSON(response)
-    return response
-  }
-}

package/src/auth/refresh.ts

@@ -1,102 +0,0 @@
-import { buildOAuthRefreshError, normalizeReason, type OAuthInfo } from "../constants"
-import { withRetry } from "./retry"
-import type { AuthRuntime } from "./types"
-
-async function postOAuthToken(url: string, init: RequestInit, deps: AuthRuntime): Promise<Response> {
-  return withRetry(
-    () =>
-      deps.fetchImpl(url, init).then(async (result) => {
-        if (!result.ok) {
-          const error = new Error(`HTTP ${result.status}`) as Error & { response?: Response; status?: number }
-          error.response = result
-          error.status = result.status
-          throw error
-        }
-        return result
-      }),
-    deps,
-  )
-}
-
-export async function refreshAnthropic(info: OAuthInfo, deps: AuthRuntime): Promise<OAuthInfo> {
-  const response = await postOAuthToken(
-    "https://console.anthropic.com/v1/oauth/token",
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        grant_type: "refresh_token",
-        refresh_token: info.refresh,
-        client_id: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
-      }),
-    },
-    deps,
-  )
-
-  let body: Record<string, unknown>
-  try {
-    body = (await response.json()) as Record<string, unknown>
-  } catch (error) {
-    throw buildOAuthRefreshError("anthropic", normalizeReason(error))
-  }
-
-  if (typeof body.access_token !== "string" || typeof body.refresh_token !== "string") {
-    throw buildOAuthRefreshError("anthropic", "Invalid token response")
-  }
-
-  return {
-    type: "oauth",
-    access: body.access_token,
-    refresh: body.refresh_token,
-    expires: Date.now() + (typeof body.expires_in === "number" ? body.expires_in : 3600) * 1000,
-    accountId: info.accountId,
-    enterpriseUrl: info.enterpriseUrl,
-  }
-}
-
-export async function refreshOpenAI(info: OAuthInfo, deps: AuthRuntime): Promise<OAuthInfo> {
-  const response = await postOAuthToken(
-    "https://auth.openai.com/oauth/token",
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        grant_type: "refresh_token",
-        refresh_token: info.refresh,
-        client_id: "app_EMoamEEZ73f0CkXaXp7hrann",
-      }),
-    },
-    deps,
-  )
-
-  let parsed: Record<string, unknown>
-  try {
-    parsed = (await response.json()) as Record<string, unknown>
-  } catch (error) {
-    throw buildOAuthRefreshError("openai", normalizeReason(error))
-  }
-
-  if (typeof parsed.access_token !== "string" || typeof parsed.refresh_token !== "string") {
-    throw buildOAuthRefreshError("openai", "Invalid token response")
-  }
-
-  return {
-    type: "oauth",
-    access: parsed.access_token,
-    refresh: parsed.refresh_token,
-    expires: Date.now() + (typeof parsed.expires_in === "number" ? parsed.expires_in : 3600) * 1000,
-    accountId: info.accountId,
-    enterpriseUrl: info.enterpriseUrl,
-  }
-}
-
-export async function exchangeCopilotToken(info: OAuthInfo, deps: AuthRuntime): Promise<{ token: string }> {
-  const response = await postOAuthToken(
-    "https://api.github.com/copilot_internal/v2/token",
-    { method: "GET", headers: { Authorization: `token ${info.refresh}` } },
-    deps,
-  )
-  const parsed = (await response.json()) as Record<string, unknown>
-  if (typeof parsed.token !== "string") throw buildOAuthRefreshError("github-copilot", "Invalid token response")
-  return { token: parsed.token }
-}

package/src/auth/retry.ts

@@ -1,70 +0,0 @@
-import { normalizeReason } from "../constants"
-import { headerValue } from "./headers"
-import type { AuthDependencies } from "./types"
-
-function getStatus(error: unknown): number | undefined {
-  if (!error || typeof error !== "object") return undefined
-  const record = error as Record<string, unknown>
-  if (typeof record.status === "number") return record.status
-  if (typeof record.statusCode === "number") return record.statusCode
-  const response = record.response
-  if (response && typeof response === "object") {
-    const maybeStatus = (response as Record<string, unknown>).status
-    if (typeof maybeStatus === "number") return maybeStatus
-  }
-  return undefined
-}
-
-function getRetryAfterMs(error: unknown): number {
-  if (!error || typeof error !== "object") return 2000
-  const response = (error as Record<string, unknown>).response
-  if (response && typeof response === "object") {
-    const headers = (response as { headers?: Headers }).headers
-    if (headers instanceof Headers) {
-      const retryAfter = headerValue(headers, "retry-after")
-      if (!retryAfter) return 2000
-      const seconds = Number(retryAfter)
-      if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000)
-      const date = Date.parse(retryAfter)
-      if (Number.isFinite(date)) return Math.max(0, date - Date.now())
-    }
-  }
-  return 2000
-}
-
-function isRetryableError(error: unknown): boolean {
-  const status = getStatus(error)
-  if (status === 429) return true
-  if (status !== undefined) return status >= 500
-  const message = normalizeReason(error).toLowerCase()
-  return (
-    message.includes("network") ||
-    message.includes("fetch") ||
-    message.includes("timeout") ||
-    message.includes("socket") ||
-    message.includes("econn")
-  )
-}
-
-export async function withRetry<T>(
-  task: () => Promise<T>,
-  deps: Required<Pick<AuthDependencies, "sleep">>,
-): Promise<T> {
-  let lastError: unknown
-  for (let attempt = 0; attempt < 3; attempt += 1) {
-    try {
-      return await task()
-    } catch (error) {
-      lastError = error
-      if (!isRetryableError(error)) throw error
-      if (getStatus(error) === 429) {
-        if (attempt >= 1) throw error
-        await deps.sleep(getRetryAfterMs(error))
-        continue
-      }
-      if (attempt >= 2) throw error
-      await deps.sleep(attempt === 0 ? 500 : 1500)
-    }
-  }
-  throw lastError
-}

package/src/auth/store.ts

@@ -1,98 +0,0 @@
-import { readFile } from "node:fs/promises"
-import os from "node:os"
-import path from "node:path"
-import { type AuthInfo, OAUTH_DUMMY_KEY, type OAuthInfo } from "../constants"
-import type { AuthDependencies } from "./types"
-
-// Mirrors opencode's xdg-basedir data location; see packages/core/src/global.ts.
-function dataHome(): string {
-  const xdgDataHome = process.env.XDG_DATA_HOME
-  if (xdgDataHome) return xdgDataHome
-  return path.join(os.homedir(), ".local", "share")
-}
-
-function authFilePaths(): string[] {
-  const root = path.join(dataHome(), "opencode")
-  return [path.join(root, "auth.json"), path.join(root, "auth-v2.json")]
-}
-
-export function normalizeProviderKey(value: string | undefined): string | undefined {
-  if (!value || value === OAUTH_DUMMY_KEY) return undefined
-  return value
-}
-
-export function ensureOAuthInfo(value: AuthInfo | undefined): OAuthInfo | undefined {
-  return value && value.type === "oauth" ? value : undefined
-}
-
-function isAuthInfo(value: unknown): value is AuthInfo {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false
-  const record = value as Record<string, unknown>
-  if (record.type === "api") return typeof record.key === "string"
-  if (record.type === "oauth") {
-    return typeof record.access === "string" && typeof record.refresh === "string" && typeof record.expires === "number"
-  }
-  if (record.type === "wellknown") return typeof record.key === "string" && typeof record.token === "string"
-  return false
-}
-
-function normalizeAuthMap(raw: unknown): Record<string, AuthInfo> | undefined {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined
-  const record = raw as Record<string, unknown>
-
-  if (
-    record.version === 2 &&
-    record.accounts &&
-    typeof record.accounts === "object" &&
-    !Array.isArray(record.accounts)
-  ) {
-    const accounts = record.accounts as Record<string, unknown>
-    const active =
-      record.active && typeof record.active === "object" && !Array.isArray(record.active) ? record.active : {}
-    const result: Record<string, AuthInfo> = {}
-
-    for (const [serviceID, accountID] of Object.entries(active as Record<string, unknown>)) {
-      if (typeof accountID !== "string") continue
-      const account = accounts[accountID]
-      if (!account || typeof account !== "object" || Array.isArray(account)) continue
-      const credential = (account as Record<string, unknown>).credential
-      if (isAuthInfo(credential)) result[serviceID] = credential
-    }
-
-    for (const account of Object.values(accounts)) {
-      if (!account || typeof account !== "object" || Array.isArray(account)) continue
-      const accountRecord = account as Record<string, unknown>
-      const serviceID = accountRecord.serviceID
-      const credential = accountRecord.credential
-      if (typeof serviceID === "string" && result[serviceID] === undefined && isAuthInfo(credential)) {
-        result[serviceID] = credential
-      }
-    }
-
-    return result
-  }
-
-  const result: Record<string, AuthInfo> = {}
-  for (const [providerID, info] of Object.entries(record)) {
-    if (isAuthInfo(info)) result[providerID] = info
-  }
-  return result
-}
-
-export async function readAuthMap(deps: AuthDependencies): Promise<Record<string, AuthInfo> | undefined> {
-  if (process.env.OPENCODE_AUTH_CONTENT) {
-    try {
-      return normalizeAuthMap(JSON.parse(process.env.OPENCODE_AUTH_CONTENT))
-    } catch {}
-    return undefined
-  }
-
-  for (const filePath of authFilePaths()) {
-    try {
-      const raw = await (deps.readFile ?? readFile)(filePath, "utf8")
-      const parsed = normalizeAuthMap(JSON.parse(raw))
-      if (parsed) return parsed
-    } catch {}
-  }
-  return undefined
-}

package/src/auth/types.ts

@@ -1,27 +0,0 @@
-import type { AuthInfo, FetchLike, OAuthInfo, ProviderInfo } from "../constants"
-
-export interface ResolvedCredential {
-  providerID: string
-  provider?: ProviderInfo
-  authInfo?: AuthInfo
-  apiKey?: string
-  fetch?: FetchLike
-  mode: "apiKey" | "oauth" | "default"
-}
-
-export interface AuthDependencies {
-  fetchImpl?: FetchLike
-  now?: () => number
-  sleep?: (ms: number) => Promise<void>
-  readFile?: (filePath: string, encoding: BufferEncoding) => Promise<string>
-  packageVersion?: string
-}
-
-export type AuthRuntime = Required<Pick<AuthDependencies, "fetchImpl" | "sleep">>
-
-export type OAuthResolver = (providerID: string) => Promise<OAuthInfo | undefined>
-
-export interface CodexBodyRewrite {
-  body: BodyInit | null | undefined
-  originalStream: boolean
-}

package/src/auth.ts

@@ -1 +0,0 @@
-export * from "./auth/index"

package/src/constants/errors.ts

@@ -1,24 +0,0 @@
-import { PLUGIN_NAME } from "./plugin"
-
-export function normalizeReason(error: unknown): string {
-  const raw = error instanceof Error ? error.message : String(error)
-  return raw.split(/\r?\n/, 1)[0].trim().slice(0, 200)
-}
-
-export function buildInboundTranslationError(userLanguage: string, reason: string): Error {
-  return new Error(
-    `[${PLUGIN_NAME}:INBOUND_TRANSLATION_FAILED] Failed to translate user message from ${userLanguage} to English: ${reason}`,
-  )
-}
-
-export function buildAuthUnavailableError(providerID: string, envVar: string): Error {
-  return new Error(
-    `[${PLUGIN_NAME}:AUTH_UNAVAILABLE] No credential found for provider "${providerID}". Set ${envVar} in the environment or run "opencode auth login ${providerID}".`,
-  )
-}
-
-export function buildOAuthRefreshError(providerID: string, reason: string): Error {
-  return new Error(
-    `[${PLUGIN_NAME}:OAUTH_REFRESH_FAILED] Failed to refresh OAuth token for provider "${providerID}": ${reason}. Re-authenticate with "opencode auth login ${providerID}".`,
-  )
-}

package/src/constants/guards.ts

@@ -1,33 +0,0 @@
-import { LLM_LANGUAGE, NONCE_PATTERN } from "./plugin"
-import type { SDKResponseLike, TextPartLike, TranslateState } from "./types"
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.length > 0
-}
-
-export function unwrapData<T>(value: T | SDKResponseLike<T>): T {
-  if (value && typeof value === "object" && "data" in value && (value as SDKResponseLike<T>).data !== undefined) {
-    return (value as SDKResponseLike<T>).data as T
-  }
-  return value as T
-}
-
-export function isTranslateStateRecord(value: unknown): value is TranslateState {
-  if (!value || typeof value !== "object") return false
-  const record = value as Record<string, unknown>
-  return (
-    record.translate_enabled === true &&
-    record.translate_llm_lang === LLM_LANGUAGE &&
-    isNonEmptyString(record.translate_user_lang) &&
-    isNonEmptyString(record.translate_nonce) &&
-    NONCE_PATTERN.test(record.translate_nonce)
-  )
-}
-
-export function isTextPart(part: TextPartLike): part is TextPartLike & { text: string } {
-  return part.type === "text" && typeof part.text === "string"
-}
-
-export function isUserAuthoredTextPart(part: TextPartLike): part is TextPartLike & { text: string } {
-  return isTextPart(part) && part.synthetic !== true && part.ignored !== true
-}

package/src/constants/options.ts

@@ -1,55 +0,0 @@
-import { AUTH_ENV_FALLBACK, DEFAULT_TRIGGER, PLUGIN_NAME } from "./plugin"
-import type { ProviderInfo, ResolvedTranslateOptions } from "./types"
-
-export function resolveOptions(options: Record<string, unknown>): ResolvedTranslateOptions {
-  const model = typeof options.model === "string" ? options.model.trim() : ""
-  if (!model) {
-    throw new Error(
-      `[${PLUGIN_NAME}:INVALID_OPTIONS] options.model is required. Set it to the translator model, e.g. "anthropic/claude-haiku-4-5".`,
-    )
-  }
-  const slash = model.indexOf("/")
-  if (slash < 1 || slash === model.length - 1) {
-    throw new Error(
-      `[${PLUGIN_NAME}:INVALID_OPTIONS] options.model must be in provider/model-id form, e.g. "anthropic/claude-haiku-4-5".`,
-    )
-  }
-
-  const lang = typeof options.lang === "string" ? options.lang.trim() : ""
-  if (!lang) {
-    throw new Error(
-      `[${PLUGIN_NAME}:INVALID_OPTIONS] options.lang is required. Set it to the user's language, e.g. "Korean" or "Japanese".`,
-    )
-  }
-  const variant = typeof options.variant === "string" ? options.variant.trim() : ""
-
-  const rawTrigger = Array.isArray(options.trigger)
-    ? options.trigger
-    : Array.isArray(options.triggerKeywords)
-      ? options.triggerKeywords
-      : DEFAULT_TRIGGER
-  const trigger = rawTrigger.filter((value): value is string => typeof value === "string" && value.length > 0)
-
-  return {
-    model,
-    ...(variant ? { variant } : {}),
-    trigger: trigger.length > 0 ? trigger : [...DEFAULT_TRIGGER],
-    lang,
-    verbose: options.verbose === true,
-  }
-}
-
-export function getEnvVarHint(provider: ProviderInfo | undefined): string {
-  return provider?.env[0] || AUTH_ENV_FALLBACK
-}
-
-export function parseTranslatorModel(model: string): { providerID: string; modelID: string } {
-  const slash = model.indexOf("/")
-  if (slash < 1 || slash === model.length - 1) {
-    return { providerID: "anthropic", modelID: model }
-  }
-  return {
-    providerID: model.slice(0, slash),
-    modelID: model.slice(slash + 1),
-  }
-}

package/src/constants/plugin.ts

@@ -1,9 +0,0 @@
-export const PLUGIN_NAME = "opencode-translate"
-export const SPEC_VERSION = 2
-export const LLM_LANGUAGE = "English"
-export const DEFAULT_TRIGGER = ["$en"]
-export const OAUTH_DUMMY_KEY = "opencode-oauth-dummy-key"
-export const NONCE_PATTERN = /^[0-9a-f]{32}$/
-export const FAILURE_NOTICE = "_Translation unavailable for this segment._"
-export const AUTH_ENV_FALLBACK = "the provider's API key env var"
-export const USER_AGENT = `${PLUGIN_NAME}/0.0.0`

package/src/constants/types.ts

@@ -1,159 +0,0 @@
-import type { LLM_LANGUAGE } from "./plugin"
-
-export type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
-
-type ProviderSource = "env" | "config" | "custom" | "api"
-
-export interface ResolvedTranslateOptions {
-  model: string
-  variant?: string
-  trigger: string[]
-  lang: string
-  verbose: boolean
-}
-
-export interface TranslateState {
-  translate_enabled: true
-  translate_user_lang: string
-  translate_llm_lang: typeof LLM_LANGUAGE
-  translate_nonce: string
-}
-
-export interface StoredTextMetadata extends Record<string, unknown> {
-  translate_enabled?: boolean
-  translate_user_lang?: string
-  translate_llm_lang?: string
-  translate_nonce?: string
-  translate_role?: string
-  translate_spec_version?: number
-  translate_source_hash?: string
-  translate_en?: string
-  translate_part_index?: number
-  compaction_continue?: boolean
-}
-
-interface SessionLike {
-  id: string
-  parentID?: string | null
-}
-
-interface MessageLike {
-  id: string
-  sessionID: string
-  role: string
-}
-
-export interface TextPartLike {
-  id: string
-  sessionID: string
-  messageID: string
-  type: string
-  text?: string
-  synthetic?: boolean
-  ignored?: boolean
-  metadata?: Record<string, unknown>
-}
-
-export interface MessageWithPartsLike {
-  info: MessageLike
-  parts: TextPartLike[]
-}
-
-export interface ProviderModelInfo {
-  id?: string
-  api?: {
-    id?: string
-    url?: string
-    npm?: string
-  }
-  headers?: Record<string, string>
-  options?: Record<string, unknown>
-  variants?: Record<string, Record<string, unknown>>
-  capabilities?: {
-    temperature?: boolean
-  }
-}
-
-export interface ProviderInfo {
-  id: string
-  source: ProviderSource
-  env: string[]
-  key?: string
-  options?: Record<string, unknown>
-  models?: Record<string, ProviderModelInfo>
-}
-
-interface ProviderListResponseLike {
-  all: ProviderInfo[]
-}
-
-interface ApiAuthInfo {
-  type: "api"
-  key: string
-  metadata?: Record<string, string>
-}
-
-export interface OAuthInfo {
-  type: "oauth"
-  refresh: string
-  access: string
-  expires: number
-  accountId?: string
-  enterpriseUrl?: string
-}
-
-interface WellKnownInfo {
-  type: "wellknown"
-  key: string
-  token: string
-}
-
-export type AuthInfo = ApiAuthInfo | OAuthInfo | WellKnownInfo
-
-export interface SDKResponseLike<T> {
-  data?: T
-}
-
-export interface PluginClientLike {
-  session: {
-    get(
-      input: (
-        | { sessionID: string; directory?: string; workspace?: string }
-        | { path: { id: string }; query?: { directory?: string; workspace?: string } }
-      ) & { throwOnError?: boolean },
-      options?: { throwOnError?: boolean },
-    ): Promise<SessionLike | SDKResponseLike<SessionLike>>
-    messages(
-      input: (
-        | { sessionID: string; directory?: string; workspace?: string }
-        | { path: { id: string }; query?: { directory?: string; workspace?: string; limit?: number; before?: string } }
-      ) & { throwOnError?: boolean },
-      options?: { throwOnError?: boolean },
-    ): Promise<MessageWithPartsLike[] | SDKResponseLike<MessageWithPartsLike[]>>
-    message(
-      input: (
-        | { sessionID: string; messageID: string; directory?: string; workspace?: string }
-        | { path: { id: string; messageID: string }; query?: { directory?: string; workspace?: string } }
-      ) & { throwOnError?: boolean },
-      options?: { throwOnError?: boolean },
-    ): Promise<MessageWithPartsLike | SDKResponseLike<MessageWithPartsLike>>
-  }
-  provider: {
-    list(options?: {
-      throwOnError?: boolean
-    }): Promise<ProviderListResponseLike | SDKResponseLike<ProviderListResponseLike>>
-  }
-  auth: {
-    set(input: { path: { id: string }; body: AuthInfo }): Promise<unknown>
-  }
-  app: {
-    log(input: {
-      body: {
-        service: string
-        level: string
-        message: string
-        extra?: Record<string, unknown>
-      }
-    }): Promise<unknown>
-  }
-}