Home /Modules/artificial-intelligence/sleela_llm_demo.c

sleela_llm_demo.c

artificial-intelligence/large-language-models/sleela/sleela_llm_demo.c · 108 line(s) · c

/*
 * sleela_llm_demo.c — a Code LLM specialized for the SLeeLa language.
 *
 * Wires a deterministic stub SLeeLa-coding backend to the reasoning engine with
 * the REAL SLeeLa static verifier (sllmsl_*). The backend first proposes code
 * that violates a SLeeLa rule (a method named `record`, which is reserved); the
 * verifier refutes it; the engine backtracks and proposes valid SLeeLa with a
 * renamed method and the Metadata Class metapattern. No model/weights bundled.
 *
 * Build:
 *   cc -std=c11 -O2 -Wall -Wextra -pedantic \
 *      ../large_language_models.c ../large_language_models_reasoning.c \
 *      sleela_code_verifier.c sleela_llm_demo.c -o sleela_llm_demo
 */
#include "../large_language_models_reasoning.h"
#include "sleela_code_verifier.h"
#include <stdio.h>
#include <string.h>

typedef struct { int wrong_emitted; } stub_state;
static int has(const char* h, const char* n){ return strstr(h,n)!=NULL; }

static sllm_status sl_load(void* ud, const char* id){ (void)ud;(void)id; return SLLM_OK; }
static void sl_unload(void* ud){ (void)ud; }

static sllm_status sl_generate(void* ud, const char* prompt,
                               const sllm_generation_options* o,
                               sllm_chunk_callback cb, void* cbd){
 (void)o; stub_state* st=(stub_state*)ud; const char* line;
 if(has(prompt,"Make this step a REFLECTION")){
  line="REFLECTION: Check the draft against SLeeLa rules: reserved words, comment form, Metadata header.";
 } else if(!has(prompt,"Reasoning so far")){
  line="DECOMPOSE: Define a logger class with one method that writes a line.";
 } else if(has(prompt,"A previous path was refuted")){
  /* After the refutation: once a valid draft is on the path, conclude; else
     emit the corrected valid draft (renamed method + Metadata + << >> comment). */
  if(has(prompt,"writeLine"))
   line="CONCLUSION: Final SLeeLa: << logger >> class Logger { "
        "// ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- "
        "String metaAuthor = \"SLeeLa project\"; void writeLine(String s) { print s; } }";
  else
   line="DEDUCTION: Draft: << logger >> class Logger { "
        "// ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- "
        "String metaAuthor = \"SLeeLa project\"; void writeLine(String s) { print s; } }";
 } else if(!st->wrong_emitted){ st->wrong_emitted=1;
  /* Invalid SLeeLa: 'record' is a reserved keyword used as a method name. */
  line="DEDUCTION: Draft: class Logger { void record(String s) { print s; } }";
 } else if(has(prompt,"writeLine")){
  line="CONCLUSION: Final SLeeLa: << logger >> class Logger { "
       "// ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- "
       "String metaAuthor = \"SLeeLa project\"; void writeLine(String s) { print s; } }";
 } else {
  line="DEDUCTION: Draft: << logger >> class Logger { "
       "// ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- "
       "String metaAuthor = \"SLeeLa project\"; void writeLine(String s) { print s; } }";
 }
 return cb(line, strlen(line), cbd)? SLLM_OK : SLLM_ERROR_CANCELLED;
}

static int on_step(void* ud, const sllmr_step* s){
 (void)ud;
 printf("   [d%u #%u] %-10s %-9s c=%.2f\n     %s\n",
        s->depth, s->index, sllmr_step_kind_name(s->kind),
        sllmr_verdict_name(s->verdict), s->confidence, s->text);
 return 1;
}
static void on_bt(void* ud, uint32_t from, const char* why){
 (void)ud; printf("   -- backtrack from depth %u: %s\n", from, why);
}

int main(void){
 stub_state state={0};
 sllm_backend be={0};
 be.abi_version=SLLM_ABI_VERSION; be.name="sleela-code-stub"; be.user_data=&state;
 be.load=sl_load; be.unload=sl_unload; be.generate=sl_generate;

 sllm_engine* llm=NULL;
 if(sllm_engine_create(&be,&llm)!=SLLM_OK || sllm_engine_load(llm,"sleela-code-llm")!=SLLM_OK){
  fprintf(stderr,"demo: stub llm setup failed\n"); return 1; }

 /* The soundness half: the REAL SLeeLa static verifier. */
 sllmsl_options vo; sllmsl_options_init(&vo);
 sllmr_verifier ver=sllmsl_as_reasoning_verifier(&vo);

 sllmr_engine* re=NULL;
 if(sllmr_engine_create(llm,&ver,&re)!=SLLMR_OK){ fprintf(stderr,"demo: reasoning create failed\n"); return 1; }

 sllmr_options o; sllmr_options_init(&o);
 o.subject=SLLMR_SUBJECT_CODE; o.require_verified=1; o.max_steps=8; o.max_backtracks=2;
 sllmr_trace tr={0}; tr.on_step=on_step; tr.on_backtrack=on_bt;

 printf("== SLeeLa Code LLM: write a logger class (verified against SLeeLa rules) ==\n");
 printf(" verifier: %s\n", sllmr_engine_verifier_name(re));
 sllmr_result r;
 sllmr_status st=sllmr_reason(re,"Write a small SLeeLa class that logs a line.",&o,&tr,&r);
 printf(" status=%s  verified=%d  confidence=%.2f  backtracks=%u\n",
        sllmr_status_string(st), r.verified, r.confidence, r.backtracks);
 printf(" ANSWER: %s\n", r.answer);
 int ok = (st==SLLMR_OK && r.verified);
 sllmr_result_free(&r);

 sllmr_engine_destroy(re);
 sllm_engine_unload(llm); sllm_engine_destroy(llm);
 if(!ok){ fprintf(stderr,"sleela_llm_demo: did not reach a verified SLeeLa answer\n"); return 1; }
 printf("sleela_llm_demo: OK\n");
 return 0;
}