import { BridgeApi } from '@oro.ad/bridge-sdk'

const api = new BridgeApi({
  baseUrl: 'http://localhost:3000',
  logger: myLogger,           // optional Logger
  timeoutMs: 30_000,          // optional default client-side timeout
  defaultHeaders: {           // optional
    'X-Client-Id': 'my-app'
  }
})

const sessions: SessionSummary[] = await api.listSessions()

const session = await api.getSession('claude_abc123')

const { conversationId } = await api.createSession({
  title: 'My Session'
})

const result = await api.adoptSession({
  claudeSessionId: 'sess_xyz',
  title: 'Adopted Session'
})

const { loop } = await api.updateSession(conversationId, { title: 'New Title', model: null })
// or shorthand:
await api.updateSessionTitle(conversationId, 'New Title')

await api.deleteSession(conversationId)

await api.compactSession(conversationId)

await api.clearSession(conversationId)

const { loop } = await api.setLoopMode(conversationId, {
  enabled: true,
  config: {
    trigger: 'idle_timeout',
    idleTimeoutSec: 300,
    resumePrompt: 'Continue working on the task.',
    maxCostUsdPerHour: 5.0
  }
})

const { autoMode } = await api.getAutoMode(conversationId)
await api.setAutoMode(conversationId, true)   // { ok, conversationId, autoMode }

const { revived, lines, path } = await api.reviveSession(conversationId)

const { servers } = await api.setSessionMcpServers(conversationId, {
  docs: { type: 'http', url: 'https://mcp.example.com', headers: { authorization: `Bearer ${token}` } }
})
// servers: ['docs']

const hits: SessionSearchHit[] = await api.searchSessions('deploy', {
  limit: 20,                 // 1–200, default 50
  signal: controller.signal  // cancel a stale query
})
// [{ bridgeSessionId, snippet, role, timestamp }]

const { messageId } = await api.sendMessage(conversationId, {
  content: 'Hello Claude!',
  attachments: [],
  senderId: 'user_123',
  senderNickname: '@john'
})

const { messages, total } = await api.getMessages(conversationId, {
  limit: 50,
  before: 'msg_xyz'   // cursor pagination
})

const message: BridgeMessage = await api.getMessage(conversationId, messageId)

const result: MessageResult = await api.getMessageResult(
  conversationId,
  messageId,
  { timeoutMs: 120_000 }
)

console.log(result.content)     // assistant response
console.log(result.costUsd)     // cost in USD
console.log(result.usage)       // token usage breakdown

// From file
const attachment = await api.uploadAttachment(conversationId, {
  filepath: '/path/to/image.png',
  filename: 'image.png',
  mimeType: 'image/png'
})

// From buffer
const attachment = await api.uploadAttachment(conversationId, {
  data: buffer,
  filename: 'doc.pdf',
  mimeType: 'application/pdf'
})

const bytes: Uint8Array = await api.downloadAttachment(attachmentId)

await api.deleteAttachment(attachmentId)

const preview: AttachmentPreview = await api.getAttachmentPreview(attachmentId)
// { id, filename, mimeType, size, lang, highlighted, reason?, html }  — html is an escaped <pre>…</pre>

const { text } = await api.transcribePreview(conversationId, {
  data: chunk,
  filename: 'chunk.webm',
  mimeType: 'audio/webm'
})

const audio: Blob | null = await api.synthesize({ text: 'Hello', voice: 'ru_RU-dmitri-medium', lengthScale: 1.1 })

const profile = await api.readVoiceProfile()   // VoiceProfile | null
const saved: boolean = await api.writeVoiceProfile({ ...profile, voiceName: 'ru_RU-dmitri-medium' })

const route: VoiceRoute | null = await api.routeVoice({ cwd: '/work/project', text: 'run the tests' })
// { sessionId, fromCache }

const me: BridgeIdentity = await api.getIdentity()
// { sub, username, email, groups, isAgent, isLocal, description?, capabilities?, appearance?, agent?, ... }

const { appearance } = await api.getAppearance()   // AgentAppearance | null
await api.setAppearance({ v: 1, head: 'visor', paint: 'teal', metal: 'steel', lens: 'navy', glow: 'cyan' })  // fields: @oro.ad/agent-look
await api.setAppearance(null)

const card: AgentCard = await api.setCard({ description: 'Reviews MRs', capabilities: ['review'] })
// { ok, description, capabilities }

const { scope, skills, syncedAt } = await api.listSkills()
const project = await api.listSkills({ cwd: '/work/project' })

await api.deleteSkill('my-skill')

const res: ApmResult = await api.installSkillPackage(
  { packageRef: 'org/skills-pack', global: true },
  { timeoutMs: 300_000 }
)
await api.uninstallSkillPackage({ packageRef: 'org/skills-pack', global: true })

await api.updateSkillPackages({ conversationId }, { timeoutMs: 300_000 })

const { skills, syncedAt } = await api.syncSkills({
  skills: [{ name: 'greet', files: { 'SKILL.md': '---\nname: greet\n---\n…' } }]
})

const { clients } = await api.listClients()
// [{ socketId, app, clientType, user, connectedAt, conversations }]

const link: HubLinkStatus = await api.getHubLink()
// { state, hubUrl, lastConnectedAt, reconnects }

const status: ReactiveStatus = await api.getReactiveStatus()
// { link, identity, spawnHealthy, claudeCommand, counters, recentDispatches }

const res: InboxDeliveryResult = await api.deliverInbox({
  channelId: 'ch_1',
  fromAgentId: 'agent_2',
  messageId: 'm_42',
  seq: 42,
  content: 'Please review !12'
})
// { status: 'delivered', routed, deduped, dispatcherUsed }

const s: CredentialStatus = await api.getCredentialStatus()
// { loaded, expiresAt, expiresInMs, reauthRequired, lastCheckedAt, lastError }

const r: CredentialReauthResult = await api.reauthCredentials({ timeoutMs: 60_000 })
if (!r.ok) console.warn(r.error)

await api.health()   // { ok: true, version?, workDir? }

const info = await api.info()
// { version, uptime, claudeVersion, workDir, activeSessions }

const api = new BridgeApi({ baseUrl, timeoutMs: 15_000 })

// Per-call override — useful for attachment uploads or long polls:
await api.uploadAttachment(id, file, { timeoutMs: 60_000 })
await api.downloadAttachment(id, { timeoutMs: 60_000 })

import {
  BridgeApiError,
  BridgeConnectError,
  BridgeTimeoutError,
  BridgeValidationError,
} from '@oro.ad/bridge-sdk'

try {
  await api.sendMessage(id, body)
}
catch (err) {
  if (err instanceof BridgeTimeoutError) { /* retry / surface */ }
  else if (err instanceof BridgeApiError && err.status === 404) { /* gone */ }
  else if (err instanceof BridgeConnectError) { /* network down */ }
  else if (err instanceof BridgeValidationError) { /* bad input */ }
  else throw err
}