sleela_ai.c
impl/core/sleela_ai.c · 201 line(s) · c
#include "sleela_ai.h"
#include <string.h>
#include <stdlib.h>
static int has_text(const char *s) { return s && *s; }
static int copy_xml_attr(const char *xml, size_t length, const char *key,
char *out, size_t out_size) {
size_t key_len = strlen(key);
size_t i;
if (!xml || !key || !out || out_size == 0) return -1;
out[0] = '\0';
for (i = 0; i + key_len + 2 <= length; ++i) {
if (memcmp(xml + i, key, key_len) == 0 && xml[i + key_len] == '=' &&
xml[i + key_len + 1] == '"') {
size_t j = i + key_len + 2;
size_t n = 0;
while (j < length && xml[j] != '"') {
if (n + 1 >= out_size) return -2;
out[n++] = xml[j++];
}
if (j >= length) return -3;
out[n] = '\0';
return 0;
}
}
return 1;
}
int slai_engine_init(SLAIEngine *engine, SLAIBackend backend) {
if (!engine || (backend != SL_AI_BACKEND_NATIVE && backend != SL_AI_BACKEND_CONNECTOR))
return -1;
memset(engine, 0, sizeof(*engine));
engine->backend = backend;
return 0;
}
int slai_engine_bind_native(SLAIEngine *engine, SLAIVMInvokeFn invoke, void *context) {
if (!engine || !invoke) return -1;
engine->invoke = invoke;
engine->context = context;
engine->backend = SL_AI_BACKEND_NATIVE;
return 0;
}
int slai_engine_bind_vm(SLAIEngine *engine, SLAIVMInvokeFn invoke, void *context) {
if (!engine || !invoke) return -1;
engine->invoke = invoke;
engine->context = context;
engine->backend = SL_AI_BACKEND_CONNECTOR;
return 0;
}
int slai_validate_input(const SLAIInput *input) {
if (!input || input->kind < SL_AI_KIND_DATA || input->kind > SL_AI_KIND_VIDEO)
return -1;
if (!has_text(input->name)) return -2;
if (input->kind == SL_AI_KIND_FILE && !has_text(input->path)) return -3;
if ((input->kind == SL_AI_KIND_AUDIO || input->kind == SL_AI_KIND_VIDEO) && !input->media)
return -4;
if (input->kind == SL_AI_KIND_DATA && !input->data && input->size != 0)
return -5;
return 0;
}
int slai_validate_request(const SLAIRequest *request) {
if (!request || request->operation < SL_AI_OP_INSPECT || request->operation > SL_AI_OP_TRANSFORM)
return -1;
if (request->backend != SL_AI_BACKEND_NATIVE && request->backend != SL_AI_BACKEND_CONNECTOR)
return -2;
if (!has_text(request->model_id)) return -3;
if (request->max_observations > 0 && !request->observations) return -4;
return 0;
}
int slai_invoke(SLAIEngine *engine, const SLAIRequest *request,
const SLAIInput *input, SLAIResult *result) {
if (!engine || !result || slai_validate_request(request) || slai_validate_input(input))
return -1;
memset(result, 0, sizeof(*result));
if (!engine->invoke) return -2;
if (request->backend != engine->backend) return -3;
return engine->invoke(request, input, result, engine->context);
}
int slai_model_from_xml(const char *xml, size_t length, SLAIModelDescriptor *model) {
int rc;
if (!xml || !model || length == 0) return -1;
memset(model, 0, sizeof(*model));
rc = copy_xml_attr(xml, length, "id", model->model_id, sizeof(model->model_id));
if (rc != 0) return -2;
rc = copy_xml_attr(xml, length, "format", model->format, sizeof(model->format));
if (rc != 0) return -3;
rc = copy_xml_attr(xml, length, "source", model->source, sizeof(model->source));
if (rc != 0) return -4;
{
char revision[16];
rc = copy_xml_attr(xml, length, "revision", revision, sizeof(revision));
if (rc != 0) return -5;
model->revision = (uint32_t)strtoul(revision, NULL, 10);
}
{
char trusted[16];
rc = copy_xml_attr(xml, length, "trusted", trusted, sizeof(trusted));
if (rc != 0) return -6;
model->trusted = strcmp(trusted, "true") == 0;
}
return 0;
}
int slai_data_model_from_xml(const char *xml, size_t length, SLAIDataModel *model) {
size_t pos = 0;
if (!xml || !model || length == 0) return -1;
memset(model, 0, sizeof(*model));
if (copy_xml_attr(xml, length, "id", model->id, sizeof(model->id)) != 0) return -2;
{
char revision[16];
if (copy_xml_attr(xml, length, "revision", revision, sizeof(revision)) != 0) return -3;
model->revision = (uint32_t)strtoul(revision, NULL, 10);
}
while (pos < length && model->field_count < SL_AI_MAX_FIELDS) {
size_t i;
const char *needle = "<field ";
size_t nlen = strlen(needle);
int found = 0;
for (i = pos; i + nlen <= length; ++i) {
if (memcmp(xml + i, needle, nlen) == 0) { pos = i + nlen; found = 1; break; }
}
if (!found) break;
{
SLAIDataModelField *field = &model->fields[model->field_count];
int a = copy_xml_attr(xml + pos, length - pos, "name",
field->name, sizeof(field->name));
int b = copy_xml_attr(xml + pos, length - pos, "type",
field->type, sizeof(field->type));
char required[8];
int q = copy_xml_attr(xml + pos, length - pos, "required",
required, sizeof(required));
if (a || b) return -4;
field->required = q == 0 && strcmp(required, "true") == 0;
model->field_count++;
}
}
return 0;
}
int slai_source_from_xml(const char *xml, size_t length, SLAIXMLSource *source) {
char kind[32];
if (!xml || !source || length == 0) return -1;
memset(source, 0, sizeof(*source));
if (copy_xml_attr(xml, length, "kind", kind, sizeof(kind)) != 0) return -2;
if (copy_xml_attr(xml, length, "url", source->url, sizeof(source->url)) != 0) return -3;
(void)copy_xml_attr(xml, length, "args", source->args, sizeof(source->args));
if (strcmp(kind, "data") == 0) source->kind = SL_AI_SOURCE_DATA;
else if (strcmp(kind, "file") == 0) source->kind = SL_AI_SOURCE_FILE;
else if (strcmp(kind, "audio") == 0) source->kind = SL_AI_SOURCE_AUDIO;
else if (strcmp(kind, "video") == 0) source->kind = SL_AI_SOURCE_VIDEO;
else if (strcmp(kind, "ai-flow") == 0) source->kind = SL_AI_SOURCE_AI_FLOW;
else if (strcmp(kind, "data-flow") == 0) source->kind = SL_AI_SOURCE_DATA_FLOW;
else return -4;
return 0;
}
const char *slai_input_kind_name(SLAIInputKind kind) {
switch (kind) {
case SL_AI_KIND_DATA: return "data";
case SL_AI_KIND_FILE: return "file";
case SL_AI_KIND_AUDIO: return "audio";
case SL_AI_KIND_VIDEO: return "video";
default: return "unknown";
}
}
const char *slai_operation_name(SLAIOperation operation) {
switch (operation) {
case SL_AI_OP_INSPECT: return "inspect";
case SL_AI_OP_CLASSIFY: return "classify";
case SL_AI_OP_EXTRACT: return "extract";
case SL_AI_OP_SUMMARIZE: return "summarize";
case SL_AI_OP_TRANSFORM: return "transform";
default: return "unknown";
}
}
const char *slai_backend_name(SLAIBackend backend) {
return backend == SL_AI_BACKEND_NATIVE ? "native" :
backend == SL_AI_BACKEND_CONNECTOR ? "connector" : "unknown";
}
const char *slai_source_kind_name(SLAIXMLSourceKind kind) {
switch (kind) {
case SL_AI_SOURCE_DATA: return "data";
case SL_AI_SOURCE_FILE: return "file";
case SL_AI_SOURCE_AUDIO: return "audio";
case SL_AI_SOURCE_VIDEO: return "video";
case SL_AI_SOURCE_AI_FLOW: return "ai-flow";
case SL_AI_SOURCE_DATA_FLOW: return "data-flow";
default: return "unknown";
}
}