Swift SDK

export HINOW_API_KEY="hi_sua_chave_aqui"

import Foundation
import HinowAI

// With no arguments, the client reads the key from HINOW_API_KEY.
let client = try Hinow()

let answer = try await client.chat.completions.create(
    ChatCompletionRequest(
        model: "hinow/himax",
        messages: [
            .system("You answer in English."),
            .user("What is an API? Answer in one paragraph."),
        ]
    )
)

print(answer.choices[0].message.text)

if let uso = answer.usage {
    print("\ninput: \(uso.promptTokens) · output: \(uso.completionTokens)")
}

import Foundation
import HinowAI

let client = try Hinow()

try await client.chat.completions.createStream(
    ChatCompletionRequest(
        model: "hinow/hinova",
        messages: [.user("Write three lines about the sea at dawn.")]
    )
) { chunk in
    // Note the delta: each chunk carries the new fragment, not the whole answer.
    print(chunk.choices.first?.delta.content ?? "", terminator: "")
}

print()

import Foundation
import HinowAI

let client = try Hinow()

// Answers on the spot: there is no job to follow.
let search = try await client.tools.search(
    query: "best beaches in northeast Brazil",
    type: .search,
    country: "br",
    lang: "pt-br"
)

for item in search.results ?? [] {
    print("\(item.position ?? 0). \(item.title ?? "")")
    print("   \(item.url ?? "")")
}

print("\n\((search.results ?? []).count) results · US$ \(search.cost ?? 0)")

import Foundation
import HinowAI

let client = try Hinow()

// The crawl takes a while, so it runs as a job. This method waits for you.
let job = try await client.tools.websiteContactsAndWait(
    websites: ["https://www.teclia.com"],
    maxDepth: 2,
    maxLinksPerPage: 10
)

let cache = job.cached == true ? " (from cache)" : ""
print("status: \(job.status) · US$ \(job.cost ?? 0)\(cache)\n")

// Each item carries the type, the value and the exact page it was found on.
for item in job.result?.items ?? [] {
    switch item.type {
    case "email", "phone":
        print("\(item.type.padding(toLength: 9, withPad: " ", startingAt: 0))\(item.value)")
        print("\(String(repeating: " ", count: 9))em \(item.sourceURL ?? "")")
    default:
        print("\((item.platform ?? "").padding(toLength: 9, withPad: " ", startingAt: 0))\(item.url ?? "")")
    }
}

import Foundation
import HinowAI

// Your real function: a switch here, just for the example.
func getOrder(_ code: String) -> String {
    switch code {
    case "A-1001": return #"{"status":"delivered","delivered":"2026-08-02"}"#
    case "A-1002": return #"{"status":"in transit","estimated":"2026-08-12"}"#
    default: return #"{"error":"order not found"}"#
    }
}

let client = try Hinow()

// The argument schema, in JSON Schema. JSONValue takes Swift literals.
let schema: JSONValue = [
    "type": "object",
    "properties": [
        "code": ["type": "string", "description": "Order code, e.g. A-1001"]
    ],
    "required": ["code"],
]

// 1. The assistant: model, instructions and the functions it may call.
let assistant = try await client.beta.assistants.create(
    AssistantRequest(
        model: "hinow/himax",
        name: "Support",
        instructions: "You answer questions about orders. "
            + "Check the tool before stating any status.",
        tools: [
            .function(
                name: "get_order",
                description: "Look up an order by its code.",
                parameters: schema)
        ]
    )
)

// 2. The conversation and the question.
let thread = try await client.beta.threads.create()
try await client.beta.threads.messages.create(
    threadID: thread.id, content: "Has order A-1002 arrived?")

// 3. Run it and wait.
var run = try await client.beta.threads.runs.createAndPoll(
    threadID: thread.id, assistantID: assistant.id)

// 4. While the model asks for functions, run them and hand the result back.
while run.status == "requires_action" {
    var outputs: [ToolOutput] = []

    for call in run.requiredAction?.submitToolOutputs?.toolCalls ?? [] {
        let args = try JSONDecoder().decode(
            JSONValue.self, from: Data(call.function.arguments.utf8))
        let code = args["code"]?.stringValue ?? ""
        print("-> the model called \(call.function.name)(\(code))")

        outputs.append(ToolOutput(toolCallID: call.id, output: getOrder(code)))
    }

    try await client.beta.threads.runs.submitToolOutputs(
        threadID: thread.id, runID: run.id, outputs: outputs)
    run = try await client.beta.threads.runs.poll(threadID: thread.id, runID: run.id)
}

// 5. The final answer is the last message on the thread.
let messages = try await client.beta.threads.messages.list(
    threadID: thread.id, limit: 1, order: "desc")
print("\n\(messages.data[0].text)")

try await client.beta.assistants.delete(assistant.id)

import Foundation
import HinowAI

let client = try Hinow()

// 1. Upload the document.
let file = try await client.files.create(path: "returns-policy.txt")
print("file: \(file.id) (\(file.bytes ?? 0) bytes)")

// 2. Create the store and attach the file to it.
let base = try await client.vectorStores.create(name: "Support base")
_ = try await client.vectorStores.files.create(vectorStoreID: base.id, fileID: file.id)
print("store: \(base.id)")

// 3. Indexing is asynchronous. Searching before it finishes returns nothing
//    at all, with no error, so poll waits for it.
let state = try await client.vectorStores.files.poll(
    vectorStoreID: base.id, fileID: file.id)
print("indexing: \(state.status)\n")

// 4. Search by meaning, not by exact word.
let hits = try await client.rag.search(
    query: "How many days do I have to return an item?",
    ragID: base.id,
    topK: 3
)

for achado in hits.results {
    let excerpt = achado.text.replacingOccurrences(of: "\n", with: " ").prefix(110)
    print(String(format: "%.2f  %@", achado.score, achado.source ?? ""))
    print("      \(excerpt)…")
}

import Foundation
import HinowAI

let client = try Hinow()

do {
    let answer = try await client.chat.completions.create(
        ChatCompletionRequest(
            model: "himax", // the hinow/ prefix is missing
            messages: [.user("Olá")]
        )
    )
    print(answer.choices[0].message.text)
} catch HinowError.authentication {
    print("Invalid or expired key. Check HINOW_API_KEY.")
} catch HinowError.notFound(_, let message) {
    print("Not found: \(message)")
} catch HinowError.invalidRequest(_, let message) {
    print("Invalid request: \(message)")
} catch HinowError.rateLimit {
    print("Rate limited. The SDK already retried; wait a moment.")
} catch HinowError.connection(let message) {
    // Nothing reached the API, so nothing was charged.
    print("Sem answer da API: \(message)")
} catch let error as HinowError {
    // Safety net: any other error the API reported.
    print("Error \(error.statusCode ?? 0): \(error.localizedDescription)")
}

import Foundation
import HinowAI

let client = try Hinow()

// Account credit, in US dollars.
let balance = try await client.getBalance()
print(String(format: "balance: US$ %.2f\n", balance.balance))

// One specific model. The id is namespaced: hinow/himax, not himax.
let model = try await client.models.retrieve("hinow/himax")
print("\(model.name ?? "") (\(model.id))")
print("categories: \((model.category ?? []).joined(separator: ", "))")

if let cost = model.cost {
    print("price per million tokens: input US$ \(cost.input ?? 0) · output US$ \(cost.output ?? 0)")
}

let client = try Hinow(
    apiKey: ProcessInfo.processInfo.environment["HINOW_API_KEY"],  // ou use a variável
    baseURL: "https://api.hinow.ai",  // ou HINOW_BASE_URL
    timeout: 120,                     // segundos
    maxRetries: 2                     // repete 429 e 5xx
)