Handling Tool Execution

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

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

async function executePendingTool(tool: PendingToolCallType): Promise<IllaToolOutcomeJSON> {
  try {
    // Your executor should handle:
    // SingleTransaction / BatchTransactions / SignatureRequests / ActionSequence
    const executionResult = await walletExecutor.execute(tool.input)

    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 : 'Unknown execution error',
        ),
      )
      .toJSON()
  }
}

async function runToolLoop(
  chatId: string,
  initialTools: ReadonlyArray<PendingToolCallType>,
): Promise<void> {
  let pendingTools = [...initialTools]

  while (pendingTools.length > 0) {
    const outcomes = await Promise.all(pendingTools.map(executePendingTool))

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

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

async function executeActionSequence(steps: ActionStep[]): Promise<unknown[]> {
  const results = []

  for (const step of steps) {
    switch (step.type) {
      case 'SingleTransaction':
        results.push(await sendTransaction(step.value.transaction))
        break
      case 'BatchTransactions':
        results.push(await sendBatchTransactions(step.value))
        break
      case 'SignatureRequests':
        results.push(await collectSignatures(step.value.signatureRequests))
        break
    }
  }

  return results
}

for (const tool of pendingTools) {
  if (!tool.simulation) continue

  const sim = tool.simulation

  if (!sim.willSucceed) {
    console.warn('Simulation predicts failure:', sim.errorExplanation)
  }

  for (const change of sim.assetChanges) {
    const sign = change.direction === 'out' ? '-' : '+'
    console.log(`${sign}${change.formattedAmount} ${change.tokenSymbol} ($${change.usdValue})`)
  }

  console.log(
    `Gas: ${sim.gasEstimate.gasCostNative} ${sim.nativeTokenSymbol ?? 'ETH'} ($${sim.gasEstimate.gasCostUsd})`,
  )
}

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

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

await runToolLoop(first.chatId, first.response.data.pendingTools ?? [])

const finalMessages = await sdk.getMessages(first.chatId)
console.log(finalMessages)

const subscription = sdk.subscribeToToolStatus(
  {
    toolName: 'bridge',
    protocol: 'lifi',
    descriptor: { txHash: '0x...' },
  },
  {
    onStatusChange: ({ current }) => console.log(current.pollStatus),
    onError: (error) => console.error(error),
  },
  {
    interval: 5,
    retryThreshold: 30,
    maxRetries: 5,
    maxDuration: 600,
  },
)

subscription.unsubscribe()