sim-lib-openai-server 0.1.0

OpenAI-compatible gateway skeleton for SIM.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use std::sync::Arc;

use sim_kernel::{
    AbiVersion, Export, Lib, LibManifest, LibTarget, Linker, Result, Symbol, Version,
};

use crate::codec_openai::{install_openai_codec, openai_codec_symbol};
use crate::ops::{
    OpenAiGatewayFunction, cache_stats_symbol, capability_report_symbol, events_symbol,
    fabric_symbol, health_symbol, key_add_symbol, key_list_symbol, model_health_symbol,
    models_symbol, plan_check_symbol, plan_combinators_symbol, plan_explain_symbol,
    plan_parse_symbol, plan_run_symbol, run_get_symbol, runs_symbol, serve_symbol,
    storage_stats_symbol,
};

const OPENAI_GATEWAY_LIB_ID: &str = "openai-gateway";

/// Loadable library that installs the OpenAI-compatible gateway surface.
///
/// Implements [`Lib`]: its manifest declares the gateway's id, version, ABI,
/// and exports, and its loader registers the OpenAI codec plus every
/// [`OpenAiGatewayFunction`] under its operation symbol.
pub struct OpenAiGatewayLib;

impl Lib for OpenAiGatewayLib {
    fn manifest(&self) -> LibManifest {
        LibManifest {
            id: manifest_name(),
            version: Version(env!("CARGO_PKG_VERSION").to_owned()),
            abi: AbiVersion { major: 0, minor: 1 },
            target: LibTarget::HostRegistered,
            requires: Vec::new(),
            capabilities: Vec::new(),
            exports: openai_gateway_exports(),
        }
    }

    fn load(&self, cx: &mut sim_kernel::LoadCx, linker: &mut Linker<'_>) -> Result<()> {
        install_openai_codec(linker)?;
        for function in [
            OpenAiGatewayFunction::serve(),
            OpenAiGatewayFunction::health(),
            OpenAiGatewayFunction::models(),
            OpenAiGatewayFunction::plan_parse(),
            OpenAiGatewayFunction::plan_check(),
            OpenAiGatewayFunction::plan_run(),
            OpenAiGatewayFunction::plan_explain(),
            OpenAiGatewayFunction::plan_combinators(),
            OpenAiGatewayFunction::fabric(),
            OpenAiGatewayFunction::key_add(),
            OpenAiGatewayFunction::key_list(),
            OpenAiGatewayFunction::runs(),
            OpenAiGatewayFunction::run_get(),
            OpenAiGatewayFunction::events(),
            OpenAiGatewayFunction::storage_stats(),
            OpenAiGatewayFunction::model_health(),
            OpenAiGatewayFunction::cache_stats(),
            OpenAiGatewayFunction::capability_report(),
        ] {
            linker.function_value(function.symbol(), cx.factory().opaque(Arc::new(function))?)?;
        }
        Ok(())
    }
}

/// Returns the library's manifest id symbol, `sim/openai-gateway`.
pub fn manifest_name() -> Symbol {
    Symbol::qualified("sim", OPENAI_GATEWAY_LIB_ID)
}

/// Returns the full export list for the gateway library: every operation
/// function symbol plus the OpenAI codec.
pub fn openai_gateway_exports() -> Vec<Export> {
    let mut exports = [
        serve_symbol(),
        health_symbol(),
        models_symbol(),
        plan_parse_symbol(),
        plan_check_symbol(),
        plan_run_symbol(),
        plan_explain_symbol(),
        plan_combinators_symbol(),
        fabric_symbol(),
        key_add_symbol(),
        key_list_symbol(),
        runs_symbol(),
        run_get_symbol(),
        events_symbol(),
        storage_stats_symbol(),
        model_health_symbol(),
        cache_stats_symbol(),
        capability_report_symbol(),
    ]
    .into_iter()
    .map(|symbol| Export::Function {
        symbol,
        function_id: None,
    })
    .collect::<Vec<_>>();
    exports.push(Export::Codec {
        symbol: openai_codec_symbol(),
        codec_id: None,
    });
    exports
}