ai.h

Go to the documentation of this file.

 
#ifndef CSILK_AI_H
#define CSILK_AI_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
typedef struct {
    uint64_t requests_total;    
    uint64_t tokens_total;      
    uint64_t prompt_tokens;     
    uint64_t completion_tokens; 
    uint64_t errors_total;      
    uint64_t duration_us_total; 
} csilk_ai_stats_t;
 
void csilk_ai_get_stats(csilk_ai_stats_t* stats);
 
char* csilk_ai_stats_to_json(const csilk_ai_stats_t* stats);
 
void csilk_ai_register_monitor(void* c);
 
typedef struct csilk_ai_s csilk_ai_t;
 
typedef struct {
    const char* role;    
    const char* content; 
} csilk_ai_message_t;
 
typedef void (*csilk_ai_stream_cb)(const char* chunk, void* user_data);
 
typedef struct {
    const char* name;    
    const char* description; 
    void* parameters_json;   
} csilk_ai_tool_function_t;
 
typedef struct {
    const char* type; 
    csilk_ai_tool_function_t function;
} csilk_ai_tool_t;
 
typedef struct {
    char* id;    
    char* name;  
    char* arguments; 
} csilk_ai_tool_call_t;
 
typedef struct {
    const char* model;        
    csilk_ai_message_t* messages; 
    size_t message_count;         
    double temperature;       
    double top_p;             
    double presence_penalty;      
    double frequency_penalty;     
    int max_tokens;           
    const char** stop;        
    size_t stop_count;        
    const char* user;         
    bool stream;              
    csilk_ai_stream_cb on_chunk;  
    void* user_data;          
    int timeout_ms;           
    csilk_ai_tool_t* tools;       
    size_t tool_count;        
    const char* tool_choice;      
} csilk_ai_chat_request_t;
 
typedef struct {
    char* content;            
    csilk_ai_tool_call_t* tool_calls; 
    size_t tool_call_count;       
    int prompt_tokens;        
    int completion_tokens;        
    int total_tokens;         
    char* raw_response;       
    char* error_message;          
} csilk_ai_chat_response_t;
 
typedef struct {
    float* values;    
    size_t dimension; 
    size_t count;     
    int prompt_tokens;
    int total_tokens;
    char* error_message;
} csilk_ai_embeddings_response_t;
 
typedef void (*csilk_ai_chat_async_cb)(int status, csilk_ai_chat_response_t* res, void* user_data);
 
typedef void (*csilk_ai_embeddings_async_cb)(int status,
                         csilk_ai_embeddings_response_t* res,
                         void* user_data);
 
typedef struct {
    const char* name; 
    void* (*init)(const char* api_key, const char* base_url);
    int (*chat)(void* state, const csilk_ai_chat_request_t* req, csilk_ai_chat_response_t* res);
    int (*embeddings)(void* state,
              const char* model,
              const char** input,
              size_t count,
              csilk_ai_embeddings_response_t* res);
    void (*free)(void* state);
} csilk_ai_driver_t;
 
typedef struct {
    csilk_ai_message_t* messages; 
    size_t count;             
    size_t capacity;          
    size_t max_history;       
} csilk_ai_context_t;
 
/* --- Core API --- */
 
csilk_ai_t* csilk_ai_new(const char* driver_name, const char* api_key, const char* base_url);
 
int
csilk_ai_chat(csilk_ai_t* ai, const csilk_ai_chat_request_t* req, csilk_ai_chat_response_t* res);
 
void csilk_ai_chat_async(csilk_ai_t* ai,
             const csilk_ai_chat_request_t* req,
             csilk_ai_chat_async_cb cb,
             void* user_data);
 
int csilk_ai_embeddings(csilk_ai_t* ai,
            const char* model,
            const char** input,
            size_t count,
            csilk_ai_embeddings_response_t* res);
 
void csilk_ai_embeddings_async(csilk_ai_t* ai,
                   const char* model,
                   const char** input,
                   size_t count,
                   csilk_ai_embeddings_async_cb cb,
                   void* user_data);
 
void csilk_ai_free(csilk_ai_t* ai);
 
void csilk_ai_chat_response_free(csilk_ai_chat_response_t* res);
 
void csilk_ai_embeddings_response_free(csilk_ai_embeddings_response_t* res);
 
void csilk_ai_register_driver(const csilk_ai_driver_t* driver);
 
/* --- Context Helpers --- */
 
csilk_ai_context_t* csilk_ai_context_new(size_t max_history);
 
void csilk_ai_context_add(csilk_ai_context_t* ctx, const char* role, const char* content);
 
void csilk_ai_context_clear(csilk_ai_context_t* ctx);
 
void csilk_ai_context_free(csilk_ai_context_t* ctx);
 
#endif /* CSILK_AI_H */