Outils et exemples de code

// Contexte : votre agent utilise des outils (tool calling)
// pour interagir avec l'API Arrhes.
// Authentification : cookie de session obtenu après connexion.

// Outil : lister les écritures d'un exercice
async function listEntries(
  sessionCookie: string,
  idOrganization: string,
  idYear: string
): Promise<Entry[]> {
  const response = await fetch(
    `https://api.arrhes.com/organizations/${idOrganization}/years/${idYear}/entries`,
    {
      headers: {
        Cookie: sessionCookie,
        "Content-Type": "application/json",
      },
    }
  )
  const data = await response.json()
  return data
}

// Outil : créer une écriture comptable
async function createEntry(
  sessionCookie: string,
  idOrganization: string,
  idYear: string,
  entry: {
    date: string
    idJournal: string
    label: string
    lines: Array<{
      idAccount: string
      debit?: string
      credit?: string
    }>
  }
): Promise<Entry> {
  const response = await fetch(
    `https://api.arrhes.com/organizations/${idOrganization}/years/${idYear}/entries`,
    {
      method: "POST",
      headers: {
        Cookie: sessionCookie,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(entry),
    }
  )
  return response.json()
}

// Outil : OCR d'un fichier
async function ocrFile(
  sessionCookie: string,
  idOrganization: string,
  idYear: string,
  idFile: string
): Promise<{ file: File }> {
  const response = await fetch(
    `https://api.arrhes.com/organizations/${idOrganization}/years/${idYear}/files/${idFile}/ocr`,
    {
      method: "POST",
      headers: {
        Cookie: sessionCookie,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ idFile }),
    }
  )
  return response.json()
}

# Contexte : votre agent utilise des appels API REST
# pour interagir avec les donnees Arrhes.
# Authentification : cookie de session obtenu apres connexion.

import httpx
from typing import Any

API_BASE = "https://api.arrhes.com"

class ArrhesClient:
    def __init__(self, session_cookie: str, org_id: str):
        self.headers = {
            "Cookie": session_cookie,
            "Content-Type": "application/json",
        }
        self.org_id = org_id

    def list_entries(self, year_id: str) -> list[dict[str, Any]]:
        """Lister les ecritures d'un exercice."""
        url = f"{API_BASE}/organizations/{self.org_id}/years/{year_id}/entries"
        response = httpx.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_entry(
        self,
        year_id: str,
        date: str,
        journal_id: str,
        label: str,
        lines: list[dict[str, Any]],
    ) -> dict[str, Any]:
        """Creer une ecriture comptable en partie double."""
        url = f"{API_BASE}/organizations/{self.org_id}/years/{year_id}/entries"
        payload = {
            "date": date,
            "idJournal": journal_id,
            "label": label,
            "lines": lines,
        }
        response = httpx.post(url, headers=self.headers, json=payload)
        response.raise_for_status()
        return response.json()

    def get_balance(self, year_id: str) -> list[dict[str, Any]]:
        """Obtenir la balance des comptes."""
        url = f"{API_BASE}/organizations/{self.org_id}/years/{year_id}/balance-sheets"
        response = httpx.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def upload_file(self, year_id: str, name: str, content: bytes, ocr: bool = False) -> dict[str, Any]:
        """Uploader un fichier avec option OCR."""
        # 1. Calculer le hash SHA256 du contenu
        from hashlib import sha256
        file_hash = sha256(content).hexdigest()
        file_reference = name.rsplit(".", 1)[0] if "." in name else name

        # 2.Uploader le fichier directement via multipart (serveur gère le S3)
        upload_resp = httpx.post(
            f"{API_BASE}/organizations/{self.org_id}/years/{year_id}/files",
            headers=self.headers,
            files={"file": (name, content, "application/octet-stream")},
            data={"name": name, "reference": file_reference, "hash": file_hash},
        )
        upload_resp.raise_for_status()
        file_data = upload_resp.json()

        # 3. Lancer l'OCR si demande
        if ocr:
            httpx.post(
                f"{API_BASE}/organizations/{self.org_id}/years/{year_id}/files/{file_data['id']}/ocr",
                headers=self.headers,
            )

        return file_data}