Types and utilities

type ChatOptions = {
  id?: string
  coreApiProvider: ICoreApiProvider
  contextManager: IContextManager
  defaultRole?: PromptRole
  modelContext?: ModelContext
  userContext: UserContext
  asyncToolChecker?: AsyncToolChecker
  personalityContext?: PersonalityContext
}

type SendMessageOptions = {
  signal?: AbortSignal
  onRequestId?: (requestId: string) => void
}

type SendMessageStreamingOptions = {
  signal?: AbortSignal
  onEvent?: (event: TelemetryEvent) => void
  onTextDelta?: (delta: string) => void
  onComplete?: (result: ValidatedResultEventData) => void
  onError?: (error: Error) => void
}

type SendMessageResult = {
  chatId: string
  requestId?: string
  prompt: CoreApiChatBodyRequest['prompt']
  promptSnapshot: PromptSnapshot | PromptSnapshot[]
  messages: MessageHistoryType
  toolsConfig: ToolAutorouterRequest
  response:
    | { isError: false; data: CoreApiChatSuccessResponse }
    | { isError: true; error: CoreApiChatErrorResponse }
}

type ChatContextSnapshot = {
  messages: MessageHistoryType
  toolsConfig: ToolAutorouterRequest
}

type AsyncToolCheckerCheckParams = {
  toolName: string
  protocol: string
  descriptor: BaseLongPollingArgs
}

type AwaitableActionDescriptor = {
  toolName: string
  protocol: string
  args: BaseLongPollingArgs
}

type PollingConfig = {
  interval: number
  maxDuration: number
  retryThreshold: number
  maxRetries: number
}

type EventSubscription = { unsubscribe(): void }

type PendingToolCallType = {
  type: 'tool-call'
  toolCallId: string
  toolName: string
  input:
    | { type: 'SingleTransaction'; value: TransactionWithMetadata }
    | { type: 'BatchTransactions'; value: TransactionWithMetadata[] }
    | { type: 'SignatureRequests'; value: { signatureRequests: SignatureRequest[] } }
    | { type: 'ActionSequence'; value: ActionStep[] }
  simulated?: boolean
  simulation?: SimulationResult
}

{
  type: 'ActionSequence',
  value: [
    { type: 'BatchTransactions', value: [{ transaction: usdcTransfer }] },
    { type: 'SignatureRequests', value: { signatureRequests: [orderSignature] } },
  ],
}

type SignatureRequest =
  | {
      signMethod: 'typedData'
      id: string
      signerAddress: string
      description?: string
      metadata?: Record<string, unknown>
      typedData: EIP712TypedData
    }
  | {
      signMethod: 'message'
      id: string
      signerAddress: string
      description?: string
      metadata?: Record<string, unknown>
      rawHash: string
    }

type SimulationResult = {
  willSucceed: boolean
  assetChanges: AssetChange[]
  gasEstimate: GasEstimate
  errorMessage?: string
  errorExplanation?: string
  simulationId?: string
  simulatedAt: number
  actionType?: SimulationActionType
  sourceChainId?: number
  destChainId?: number
  actionMetadata?: ActionMetadata
  contractInteractions?: ContractInteraction[]
  nativeTokenSymbol?: string
}

type AssetChange = {
  tokenAddress: string
  tokenSymbol: string
  tokenName: string
  decimals: number
  rawAmount: string
  formattedAmount: string
  usdValue: string
  direction: 'in' | 'out'
  logoUrl?: string
}

type GasEstimate = {
  gasLimit: string
  gasPrice: string
  gasCostNative: string
  gasCostUsd: string
}

type SimulationActionType =
  | 'transfer'
  | 'swap'
  | 'bridge'
  | 'supply'
  | 'withdraw'
  | 'contract'

type ActionMetadata = {
  inputToken?: string
  inputAmount?: string
  inputUsdValue?: string
  outputToken?: string
  outputAmount?: string
  outputUsdValue?: string
  chainName?: string
  destChainName?: string
  protocol?: string
  recipient?: string
}

type ContractInteraction = {
  address: string
  name?: string | null
  method?: string | null
  chainId: number
}

const result = await sdk.sendMessage('Hello', { userContext: { address: '0x1234...' } })

if (result.response.isError) {
  console.error(result.response.error.name, result.response.error.message)
} else {
  console.log(result.response.data.text)
  console.log(result.response.data.pendingTools)
}