IllaSDK

import { IllaSDK } from '@illalabs/sdk'

const sdk = new IllaSDK({
  apiKey: process.env.ILLA_API_KEY!,
})

const result = await sdk.sendMessage(
  'Swap 1 ETH to USDC on Base',
  { userContext: { address: '0x1234...' } },
)

new IllaSDK(config, options?)

sendMessage(
  msg: string | Prompt,
  context: { chatId: string } | { userContext: UserContext },
  chatOptions?: Omit<ChatOptions, 'userContext'>,
  options?: { signal?: AbortSignal; onRequestId?: (requestId: string) => void },
): Promise<SendMessageResult>

sendMessageStreaming(
  msg: string | Prompt,
  context: { chatId: string } | { userContext: UserContext },
  options?: SendMessageStreamingOptions,
  chatOptions?: Omit<ChatOptions, 'userContext'>,
): Promise<void>

sendToolResult(chatId: string, toolResult: IllaToolOutcomeJSON): Promise<SendMessageResult>

sendToolResults(chatId: string, toolResults: IllaToolOutcomeJSON[]): Promise<SendMessageResult>

getMessages(chatId: string): Promise<MessageHistoryType>
appendMessages(chatId: string, messages: MessageHistoryType): Promise<void>
clearContext(chatId: string): Promise<void>
deleteChat(chatId: string): Promise<void>
createChat(options: ChatOptions, contextManager?: ContextManager): Chat
getChat(chatId: string): Chat
getChatIds(): string[]

subscribeToToolStatus(
  params: { toolName: string; protocol: string; descriptor: BaseLongPollingArgs },
  callbacks: AsyncCheckerEvents,
  config?: Partial<PollingConfig>,
): EventSubscription

awaitAction(
  chatId: string,
  descriptor: { toolName: string; protocol: string; args: BaseLongPollingArgs },
): Promise<AwaitActionResult>

getResponseMetadata(result: SendMessageResult): ResponseMetadata
static createNewContextManager(cache: ICache, options: ContextManagerOptions): ContextManager

import { IllaSDK } from '@illalabs/sdk'
import { IllaToolError, IllaToolOutcome } from '@illalabs/interfaces'

const sdk = new IllaSDK({ apiKey: process.env.ILLA_API_KEY! })

const first = await sdk.sendMessage(
  'Swap 1 ETH to USDC on Base',
  {
    userContext: {
      address: '0x1234...',
      // Optional signer EOA for smart-account flows
      // signerWallet: '0x5678...'
    },
  },
)

if (first.response.isError) {
  throw new Error(first.response.error.message)
}

let pendingTools = [...(first.response.data.pendingTools ?? [])]

while (pendingTools.length > 0) {
  const outcomes = await Promise.all(
    pendingTools.map(async (tool) => {
      try {
        const executionResult = await executeTool(tool)
        return IllaToolOutcome.success(tool.toolCallId, tool.toolName, executionResult).toJSON()
      } catch (error) {
        return IllaToolOutcome.error(
          tool.toolCallId,
          tool.toolName,
          IllaToolError.execution(
            tool.toolCallId,
            tool.toolName,
            error instanceof Error ? error.message : 'Execution failed',
          ),
        ).toJSON()
      }
    }),
  )

  const followUp = await sdk.sendToolResults(first.chatId, outcomes)
  if (followUp.response.isError) {
    throw new Error(followUp.response.error.message)
  }

  pendingTools = [...(followUp.response.data.pendingTools ?? [])]
}