sim-lib-openai-server 0.1.1

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
106
107
108
109
110
111
112
113
114

use std::sync::Arc;

use sim_codec::{
    CodecDefaultDecode, CodecRuntime, Decoder, Encoder, Input, Output, ReadCx, codec_value,
};
use sim_kernel::{CodecId, DefaultFactory, Error, Factory, Linker, Result, Symbol, WriteCx};

/// Decoding of OpenAI request/response JSON into SIM transcript expressions.
pub mod decode;
/// Encoding of SIM transcript expressions into OpenAI request/response JSON.
pub mod encode;
/// Validated transcript and codec-option shapes for the OpenAI codec.
pub mod shapes;
/// Server-sent-event streaming of gateway events on OpenAI surfaces.
pub mod streaming;

pub use decode::{decode_openai_request, decode_openai_response};
pub use encode::{encode_openai_request, encode_openai_response, encode_openai_responses_response};
pub use shapes::{ChatTranscript, OpenAiCodecOptions, OpenAiRequestOptions};
pub use streaming::{
    GatewayEventData, OpenAiSseSurface, StreamSink, encode_gateway_events_sse,
    gateway_event_data_from_packet, gateway_event_data_kind, gateway_event_data_packets,
};

const OPENAI_CODEC_RUNTIME_ID: CodecId = CodecId(0);

/// Runtime codec for OpenAI-compatible chat-completion JSON fixtures.
pub struct OpenAiCodec;

impl Decoder for OpenAiCodec {
    fn decode(&self, cx: &mut ReadCx<'_>, input: Input) -> Result<sim_kernel::Expr> {
        decode::decode_openai_request_for_codec(cx.codec, input)
    }
}

impl Encoder for OpenAiCodec {
    fn encode(&self, cx: &mut WriteCx<'_>, expr: &sim_kernel::Expr) -> Result<Output> {
        encode::encode_openai_response_for_codec(cx.codec, expr).map(Output::Text)
    }
}

/// Returns the codec symbol `codec/openai`.
pub fn openai_codec_symbol() -> Symbol {
    Symbol::qualified("codec", "openai")
}

/// Registers the OpenAI codec with the linker, resolving its expression and
/// options shapes and installing it as a runtime codec value.
pub fn install_openai_codec(linker: &mut Linker<'_>) -> Result<()> {
    let factory = DefaultFactory;
    let expr_shape = linker
        .registry()
        .shape_by_symbol(&Symbol::qualified("codec", "ChatTranscript"))
        .or_else(|| {
            linker
                .registry()
                .shape_by_symbol(&Symbol::qualified("core", "Expr"))
        })
        .or_else(|| {
            linker
                .registry()
                .shape_by_symbol(&Symbol::qualified("core", "Any"))
        })
        .cloned()
        .unwrap_or(factory.nil()?);
    let options_shape = linker
        .registry()
        .shape_by_symbol(&Symbol::qualified("codec", "OpenAiCodecOptions"))
        .or_else(|| {
            linker
                .registry()
                .shape_by_symbol(&Symbol::qualified("core", "EncodeOptions"))
        })
        .or_else(|| {
            linker
                .registry()
                .shape_by_symbol(&Symbol::qualified("core", "Any"))
        })
        .cloned()
        .unwrap_or(factory.nil()?);

    let symbol = openai_codec_symbol();
    linker.codec_value(
        symbol.clone(),
        codec_value(CodecRuntime {
            id: OPENAI_CODEC_RUNTIME_ID,
            symbol,
            decoder: Some(Arc::new(OpenAiCodec)),
            located_decoder: None,
            tree_decoder: None,
            encoder: Some(Arc::new(OpenAiCodec)),
            located_encoder: None,
            tree_encoder: None,
            expr_shape,
            options_shape,
            default_decode: CodecDefaultDecode::Datum,
        }),
    )?;
    Ok(())
}

pub(crate) fn input_text(codec: CodecId, input: Input) -> Result<String> {
    match input {
        Input::Text(text) => Ok(text),
        Input::Bytes(bytes) => String::from_utf8(bytes).map_err(|err| codec_error(codec, err)),
    }
}

pub(crate) fn codec_error(codec: CodecId, message: impl ToString) -> Error {
    Error::CodecError {
        codec,
        message: message.to_string(),
    }
}