opencode-translate 1.0.6 → 2.0.0

package/src/auth/index.ts

@@ -1,177 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises"
-import {
-  AUTH_ENV_FALLBACK,
-  buildAuthUnavailableError,
-  buildOAuthRefreshError,
-  getEnvVarHint,
-  normalizeReason,
-  OAUTH_DUMMY_KEY,
-  type OAuthInfo,
-  type PluginClientLike,
-  type ProviderInfo,
-  parseTranslatorModel,
-  unwrapData,
-} from "../constants"
-import { buildOAuthFetch } from "./oauth-fetch"
-import { refreshAnthropic, refreshOpenAI } from "./refresh"
-import { ensureOAuthInfo, normalizeProviderKey, readAuthMap } from "./store"
-import type { AuthDependencies, AuthRuntime, ResolvedCredential } from "./types"
-
-export function __resetAuthCachesForTest() {
-  // Resolver instances own their caches; this remains as a stable test helper.
-}
-
-function isMissingCredentialError(error: unknown): boolean {
-  const message = normalizeReason(error).toLowerCase()
-  return (
-    message.includes("api key") ||
-    message.includes("api-key") ||
-    message.includes("missing credentials") ||
-    message.includes("missing authentication") ||
-    message.includes("missing auth") ||
-    message.includes("no auth")
-  )
-}
-
-function hasOAuthRequestAdapter(providerID: string): boolean {
-  return providerID === "anthropic" || providerID === "openai" || providerID === "github-copilot"
-}
-
-async function refreshProviderOAuth(
-  providerID: string,
-  info: OAuthInfo,
-  client: PluginClientLike,
-  runtime: AuthRuntime,
-) {
-  let refreshed: OAuthInfo
-  try {
-    if (providerID === "anthropic") refreshed = await refreshAnthropic(info, runtime)
-    else if (providerID === "openai") refreshed = await refreshOpenAI(info, runtime)
-    else return info
-  } catch (error) {
-    if (error instanceof Error && error.message.includes(":OAUTH_REFRESH_FAILED]")) throw error
-    throw buildOAuthRefreshError(providerID, normalizeReason(error))
-  }
-
-  await client.auth.set({ path: { id: providerID }, body: refreshed })
-  return refreshed
-}
-
-async function getProvider(client: PluginClientLike, providerID: string): Promise<ProviderInfo | undefined> {
-  try {
-    const listed = unwrapData(await client.provider.list({ throwOnError: true }))
-    return listed.all.find((provider) => provider.id === providerID)
-  } catch {
-    return undefined
-  }
-}
-
-export function createCredentialResolver(client: PluginClientLike, deps: AuthDependencies = {}) {
-  const credentialCache = new Map<string, ResolvedCredential>()
-  const oauthRefreshInflight = new Map<string, Promise<OAuthInfo>>()
-  const runtime: AuthRuntime = {
-    fetchImpl: deps.fetchImpl ?? fetch,
-    sleep: deps.sleep ?? ((ms: number) => sleep(ms)),
-  }
-  const now = deps.now ?? (() => Date.now())
-
-  async function resolveOAuth(providerID: string): Promise<OAuthInfo | undefined> {
-    const authMap = await readAuthMap(deps)
-    const info = ensureOAuthInfo(authMap?.[providerID])
-    if (!info) return undefined
-    if (info.expires >= now() + 60_000) return info
-
-    const inflightKey = `${providerID}:${info.refresh}`
-    const existing = oauthRefreshInflight.get(inflightKey)
-    if (existing) return existing
-
-    const refreshPromise = refreshProviderOAuth(providerID, info, client, runtime).finally(() => {
-      oauthRefreshInflight.delete(inflightKey)
-    })
-    oauthRefreshInflight.set(inflightKey, refreshPromise)
-    return refreshPromise
-  }
-
-  async function resolveAuthInfo(providerID: string) {
-    return (await readAuthMap(deps))?.[providerID]
-  }
-
-  function credentialFromOAuth(
-    providerID: string,
-    provider: ProviderInfo | undefined,
-    authInfo: OAuthInfo,
-  ): ResolvedCredential {
-    return {
-      providerID,
-      provider,
-      authInfo,
-      apiKey: "",
-      fetch: buildOAuthFetch({ ...runtime, providerID, resolveOAuth, packageVersion: deps.packageVersion }),
-      mode: "oauth",
-    }
-  }
-
-  async function resolve(providerModel: string): Promise<ResolvedCredential> {
-    const { providerID } = parseTranslatorModel(providerModel)
-    const cached = credentialCache.get(providerID)
-    if (cached && providerID !== "openai") return cached
-
-    const provider = await getProvider(client, providerID)
-    const authInfo = await resolveAuthInfo(providerID)
-    if (providerID === "openai" && authInfo?.type === "oauth") {
-      const oauthInfo = await resolveOAuth(providerID)
-      if (oauthInfo) {
-        const resolved = credentialFromOAuth(providerID, provider, oauthInfo)
-        credentialCache.set(providerID, resolved)
-        return resolved
-      }
-    }
-    if (cached && !(providerID === "openai" && cached.mode === "oauth" && authInfo?.type !== "oauth")) return cached
-
-    const providerKey = normalizeProviderKey(provider?.key)
-    if (providerKey) {
-      const resolved = { providerID, provider, authInfo, apiKey: providerKey, mode: "apiKey" as const }
-      credentialCache.set(providerID, resolved)
-      return resolved
-    }
-
-    if (authInfo?.type === "api" && authInfo.key) {
-      const resolved = { providerID, provider, authInfo, apiKey: authInfo.key, mode: "apiKey" as const }
-      credentialCache.set(providerID, resolved)
-      return resolved
-    }
-
-    if (provider?.source === "custom" || provider?.key === OAUTH_DUMMY_KEY || hasOAuthRequestAdapter(providerID)) {
-      const oauthInfo = await resolveOAuth(providerID)
-      if (oauthInfo) {
-        const resolved = credentialFromOAuth(providerID, provider, oauthInfo)
-        credentialCache.set(providerID, resolved)
-        return resolved
-      }
-    }
-
-    if (authInfo?.type === "oauth" && authInfo.access && provider?.options?.apiKey === undefined) {
-      const resolved = { providerID, provider, authInfo, apiKey: authInfo.access, mode: "oauth" as const }
-      credentialCache.set(providerID, resolved)
-      return resolved
-    }
-
-    if (provider?.key === undefined && (provider?.env.length ?? 0) > 1) {
-      const resolved = { providerID, provider, authInfo, mode: "default" as const }
-      credentialCache.set(providerID, resolved)
-      return resolved
-    }
-
-    return { providerID, provider, authInfo, mode: "default" }
-  }
-
-  return {
-    resolve,
-    authUnavailable: (providerID: string, provider?: ProviderInfo) =>
-      buildAuthUnavailableError(providerID, getEnvVarHint(provider)),
-    isMissingCredentialError,
-    envFallback: AUTH_ENV_FALLBACK,
-  }
-}
-
-export type { AuthDependencies, ResolvedCredential }

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