Yapay zekâ destekli muhasebe API'si.

struct ChatRequest: Encodable {
    let messages: [Message]
    let context: String
    struct Message: Encodable { let role: String; let content: String }
}

let body = ChatRequest(
    messages: [.init(role: "user", content: "Bu ay vergi durumum nasıl?")],
    context: "Bu ay gelir: ₺612.840, gider: ₺184.327"
)

var req = URLRequest(url: URL(string: "https://api.kilikya.app/v1/chat")!)
req.httpMethod = "POST"
req.setValue("Bearer kk_a1b2...", forHTTPHeaderField: "Authorization")
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
req.httpBody = try JSONEncoder().encode(body)

let (data, _) = try await URLSession.shared.data(for: req)
print(String(data: data, encoding: .utf8)!)

val client = OkHttpClient()
val json = """
{
  "messages": [{"role":"user","content":"Bu ay vergi durumum nasıl?"}],
  "context": "Bu ay gelir: ₺612.840, gider: ₺184.327"
}
""".trimIndent()

val req = Request.Builder()
    .url("https://api.kilikya.app/v1/chat")
    .addHeader("Authorization", "Bearer kk_a1b2...")
    .post(json.toRequestBody("application/json".toMediaType()))
    .build()

val resp = client.newCall(req).execute()
println(resp.body!!.string())

// pubspec.yaml: http: ^1.2.0
import 'dart:convert';
import 'package:http/http.dart' as http;

Future<String> askKilikon(String question) async {
  final resp = await http.post(
    Uri.parse("https://api.kilikya.app/v1/chat"),
    headers: {
      "Authorization": "Bearer kk_a1b2c3d4e5f67890abcdef1234567890",
      "Content-Type": "application/json",
    },
    body: jsonEncode({
      "messages": [
        {"role": "user", "content": question}
      ],
      "context": "Bu ay gelir: ₺612.840, gider: ₺184.327",
    }),
  );
  final data = jsonDecode(resp.body);
  return data["text"] as String;
}

void main() async {
  final reply = await askKilikon("Bu ay vergi durumum nasıl?");
  print(reply);
}

const resp = await fetch("https://api.kilikya.app/v1/chat", {
  method: "POST",
  headers: {
    "Authorization": "Bearer kk_a1b2c3d4e5f67890abcdef1234567890",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    messages: [{ role: "user", content: "Bu ay vergi durumum nasıl?" }],
    context: "Bu ay gelir: ₺612.840, gider: ₺184.327"
  })
});

const data = await resp.json();
console.log(data.text);

import requests

resp = requests.post(
    "https://api.kilikya.app/v1/chat",
    headers={
        "Authorization": "Bearer kk_a1b2c3d4e5f67890abcdef1234567890",
        "Content-Type": "application/json",
    },
    json={
        "messages": [{"role": "user", "content": "Bu ay vergi durumum nasıl?"}],
        "context": "Bu ay gelir: ₺612.840, gider: ₺184.327",
    },
)
print(resp.json()["text"])

async function retry(fn, maxAttempts = 3) {
  const delays = [500, 1500, 4000];
  for (let i = 0; i < maxAttempts; i++) {
    try {
      return await fn();
    } catch (err) {
      const retryable = [500, 502, 503, 504].includes(err.status);
      if (!retryable || i === maxAttempts - 1) throw err;
      await new Promise(r => setTimeout(r, delays[i]));
    }
  }
}

struct ConverseRequest: Encodable {
    let messages: [Msg]
    let context: Context
    struct Msg: Encodable { let role: String; let content: String }
    struct Context: Encodable {
        let company: Company
        let customers: [Customer]
        let products: [Product]
        struct Company: Encodable { let name: String; let vkn: String }
        struct Customer: Encodable { let id: String; let name: String; let vkn: String }
        struct Product: Encodable { let name: String; let price: Double; let unit: String }
    }
}

let body = ConverseRequest(
    messages: [.init(role: "user", content: "Ahmet'e 5000 lira catering kes")],
    context: .init(
        company: .init(name: "ABC A.Ş.", vkn: "4620553774"),
        customers: [.init(id: "c1", name: "Ahmet Yıldırım", vkn: "1234567890")],
        products: [.init(name: "Catering paketi", price: 2500, unit: "paket")]
    )
)
// POST to /v1/invoice/converse with Bearer header

const resp = await fetch("https://api.kilikya.app/v1/invoice/converse", {
  method: "POST",
  headers: {
    "Authorization": "Bearer kk_a1b2...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    messages: [
      { role: "user", content: "Ahmet'e 5000 lira catering kes" }
    ],
    context: {
      company: { name: "ABC A.Ş.", vkn: "4620553774" },
      customers: [{ id: "c1", name: "Ahmet Yıldırım", vkn: "1234567890" }],
      products: [{ name: "Catering paketi", price: 2500, unit: "paket" }]
    }
  })
});

const data = await resp.json();

if (data.response.state === "ready") {
  console.log("Fatura taslağı:", data.response.draft);
} else if (data.response.state === "needs_info") {
  console.log("AI soruyor:", data.response.say);
  // Kullanıcıya göster, cevabı al, sessionId ile yeni tur başlat
}

import requests

session_id = None
messages = [{"role": "user", "content": "Ahmet'e 5000 lira catering kes"}]

while True:
    resp = requests.post(
        "https://api.kilikya.app/v1/invoice/converse",
        headers={"Authorization": "Bearer kk_a1b2..."},
        json={
            "sessionId": session_id,
            "messages": messages,
            "context": {
                "company": {"name": "ABC A.Ş.", "vkn": "4620553774"},
                "customers": [{"id": "c1", "name": "Ahmet Yıldırım", "vkn": "1234567890"}],
                "products": [{"name": "Catering paketi", "price": 2500, "unit": "paket"}],
            },
        },
    )
    data = resp.json()
    session_id = data["sessionId"]
    r = data["response"]

    if r["state"] == "ready":
        print("Taslak:", r["draft"])
        break
    elif r["state"] == "needs_info":
        print("AI:", r["say"])
        user_reply = input("Sen: ")
        messages.append({"role": "assistant", "content": r["say"]})
        messages.append({"role": "user", "content": user_reply})

struct CommitRequest: Encodable {
    let email: String
    let slots: Slots
    struct Slots: Encodable {
        let customer: Customer
        let lines: [Line]
        let profile: String
        struct Customer: Encodable {
            let vkn, title, address, district, city: String
            let taxOffice: String
            let email, phone: String?
            enum CodingKeys: String, CodingKey {
                case vkn, title, address, district, city
                case taxOffice = "tax_office"
                case email, phone
            }
        }
        struct Line: Encodable {
            let productName: String
            let quantity, unitPrice, kdvRate: Double
            let unit: String
            enum CodingKeys: String, CodingKey {
                case productName = "product_name"
                case quantity
                case unitPrice = "unit_price"
                case unit
                case kdvRate = "kdv_rate"
            }
        }
    }
}
// POST to /v1/invoice/commit, decode { uuid, invoice_number, status }

const resp = await fetch("https://api.kilikya.app/v1/invoice/commit", {
  method: "POST",
  headers: { "Authorization": "Bearer kk_a1b2...", "Content-Type": "application/json" },
  body: JSON.stringify({
    email: "kullanici@firma.com",
    slots: {
      customer: {
        vkn: "1234567890", title: "Ahmet Yılmaz Ticaret",
        tax_office: "Kartal V.D.", address: "İstanbul Pendik",
        district: "Kartal", city: "İstanbul",
        email: "musteri@firma.com", phone: "05321234567"
      },
      lines: [{
        product_name: "Ahşap Sandalye",
        quantity: 4, unit_price: 3000, unit: "Adet", kdv_rate: 20
      }],
      profile: "EARSIVFATURA"
    }
  })
});
const { uuid, invoice_number, status } = await resp.json();

const reply = await fetch("https://api.kilikya.app/v1/chat", {
  method: "POST",
  headers: { "Authorization": "Bearer kk_...", "Content-Type": "application/json" },
  body: JSON.stringify({
    messages: [{ role: "user", content: "En riskli müşterim kim?" }],
    context: "Bekleyen tahsilat: Çukurova Un ₺22.500 (45 gün gecikme)"
  })
}).then(r => r.json());

console.log(reply.text);

# HBT pass-through: AI canlı cari listesinden VKN sorgular
curl https://api.kilikya.app/v1/chat \
  -H "Authorization: Bearer kk_a1b2..." \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role":"user","content":"1111111111 VKN ünvanı nedir?"}],
    "context": {
      "hbt": {
        "session_token": "eyJhbGc...",
        "vkn": "4620553774",
        "base_url": "https://econnecttest.hizliteknoloji.com.tr"
      }
    }
  }'

guard let jpeg = image.jpegData(compressionQuality: 0.7) else { return }
let base64 = jpeg.base64EncodedString()

var req = URLRequest(url: URL(string: "https://api.kilikya.app/v1/vision")!)
req.httpMethod = "POST"
req.setValue("Bearer kk_...", forHTTPHeaderField: "Authorization")
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
req.httpBody = try JSONEncoder().encode(["imageBase64": base64])

let (data, _) = try await URLSession.shared.data(for: req)
let result = try JSONDecoder().decode(VisionResponse.self, from: data)
print(result.type, result.company ?? "")

val base64 = Base64.encodeToString(jpegBytes, Base64.NO_WRAP)
val body = """{"imageBase64":"$base64"}""".toRequestBody("application/json".toMediaType())

val req = Request.Builder()
    .url("https://api.kilikya.app/v1/vision")
    .addHeader("Authorization", "Bearer kk_...")
    .post(body)
    .build()

val resp = client.newCall(req).execute()
val json = resp.body!!.string()
println(json)

let boundary = "kilikon-\(UUID().uuidString)"
var req = URLRequest(url: URL(string: "https://api.kilikya.app/v1/transcribe")!)
req.httpMethod = "POST"
req.setValue("Bearer kk_...", forHTTPHeaderField: "Authorization")
req.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

var body = Data()
func add(_ s: String) { body.append(s.data(using: .utf8)!) }
let nl = "\r\n"
add("--\(boundary)\(nl)Content-Disposition: form-data; name=\"model\"\(nl)\(nl)whisper-1\(nl)")
add("--\(boundary)\(nl)Content-Disposition: form-data; name=\"language\"\(nl)\(nl)tr\(nl)")
add("--\(boundary)\(nl)Content-Disposition: form-data; name=\"file\"; filename=\"audio.m4a\"\(nl)")
add("Content-Type: audio/m4a\(nl)\(nl)")
body.append(try Data(contentsOf: audioURL))
add(nl + "--\(boundary)--\(nl)")
req.httpBody = body

let (data, _) = try await URLSession.shared.data(for: req)

struct SpeechRequest: Encodable {
    let text: String
    let voice_id: String
    let stability: Double
    let similarity_boost: Double
    let style: Double
}

var req = URLRequest(url: URL(string: "https://api.kilikya.app/v1/speech")!)
req.httpMethod = "POST"
req.setValue("Bearer kk_...", forHTTPHeaderField: "Authorization")
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
req.httpBody = try JSONEncoder().encode(SpeechRequest(
    text: "Merhaba, fatura hazır.",
    voice_id: "fg8pljYEn5ahwjyOQaro",
    stability: 0.45,
    similarity_boost: 0.8,
    style: 0.15
))

let (data, response) = try await URLSession.shared.data(for: req)
if let http = response as? HTTPURLResponse,
   let provider = http.value(forHTTPHeaderField: "X-TTS-Provider") {
    print("TTS provider:", provider)   // "elevenlabs" veya "openai"
}

// MP3 binary'sini oynat
let player = try AVAudioPlayer(data: data)
player.play()

const resp = await fetch("https://api.kilikya.app/v1/speech", {
  method: "POST",
  headers: {
    "Authorization": "Bearer kk_...",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    text: "Merhaba, fatura hazır.",
    voice_id: "fg8pljYEn5ahwjyOQaro",
    stability: 0.45,
    similarity_boost: 0.8,
    style: 0.15
  })
});

console.log("Provider:", resp.headers.get("X-TTS-Provider"));

const blob = await resp.blob();
const url = URL.createObjectURL(blob);
new Audio(url).play();