mirror of
https://github.com/aljazceru/goose.git
synced 2025-12-18 22:54:24 +01:00
3002 lines
101 KiB
Python
3002 lines
101 KiB
Python
|
|
|
|
# This file was autogenerated by some hot garbage in the `uniffi` crate.
|
|
# Trust me, you don't want to mess with it!
|
|
|
|
# Common helper code.
|
|
#
|
|
# Ideally this would live in a separate .py file where it can be unittested etc
|
|
# in isolation, and perhaps even published as a re-useable package.
|
|
#
|
|
# However, it's important that the details of how this helper code works (e.g. the
|
|
# way that different builtin types are passed across the FFI) exactly match what's
|
|
# expected by the rust code on the other side of the interface. In practice right
|
|
# now that means coming from the exact some version of `uniffi` that was used to
|
|
# compile the rust component. The easiest way to ensure this is to bundle the Python
|
|
# helpers directly inline like we're doing here.
|
|
|
|
from __future__ import annotations
|
|
import os
|
|
import sys
|
|
import ctypes
|
|
import enum
|
|
import struct
|
|
import contextlib
|
|
import datetime
|
|
import threading
|
|
import itertools
|
|
import traceback
|
|
import typing
|
|
import asyncio
|
|
import platform
|
|
|
|
# Used for default argument values
|
|
_DEFAULT = object() # type: typing.Any
|
|
|
|
|
|
class _UniffiRustBuffer(ctypes.Structure):
|
|
_fields_ = [
|
|
("capacity", ctypes.c_uint64),
|
|
("len", ctypes.c_uint64),
|
|
("data", ctypes.POINTER(ctypes.c_char)),
|
|
]
|
|
|
|
@staticmethod
|
|
def default():
|
|
return _UniffiRustBuffer(0, 0, None)
|
|
|
|
@staticmethod
|
|
def alloc(size):
|
|
return _uniffi_rust_call(_UniffiLib.ffi_goose_llm_rustbuffer_alloc, size)
|
|
|
|
@staticmethod
|
|
def reserve(rbuf, additional):
|
|
return _uniffi_rust_call(_UniffiLib.ffi_goose_llm_rustbuffer_reserve, rbuf, additional)
|
|
|
|
def free(self):
|
|
return _uniffi_rust_call(_UniffiLib.ffi_goose_llm_rustbuffer_free, self)
|
|
|
|
def __str__(self):
|
|
return "_UniffiRustBuffer(capacity={}, len={}, data={})".format(
|
|
self.capacity,
|
|
self.len,
|
|
self.data[0:self.len]
|
|
)
|
|
|
|
@contextlib.contextmanager
|
|
def alloc_with_builder(*args):
|
|
"""Context-manger to allocate a buffer using a _UniffiRustBufferBuilder.
|
|
|
|
The allocated buffer will be automatically freed if an error occurs, ensuring that
|
|
we don't accidentally leak it.
|
|
"""
|
|
builder = _UniffiRustBufferBuilder()
|
|
try:
|
|
yield builder
|
|
except:
|
|
builder.discard()
|
|
raise
|
|
|
|
@contextlib.contextmanager
|
|
def consume_with_stream(self):
|
|
"""Context-manager to consume a buffer using a _UniffiRustBufferStream.
|
|
|
|
The _UniffiRustBuffer will be freed once the context-manager exits, ensuring that we don't
|
|
leak it even if an error occurs.
|
|
"""
|
|
try:
|
|
s = _UniffiRustBufferStream.from_rust_buffer(self)
|
|
yield s
|
|
if s.remaining() != 0:
|
|
raise RuntimeError("junk data left in buffer at end of consume_with_stream")
|
|
finally:
|
|
self.free()
|
|
|
|
@contextlib.contextmanager
|
|
def read_with_stream(self):
|
|
"""Context-manager to read a buffer using a _UniffiRustBufferStream.
|
|
|
|
This is like consume_with_stream, but doesn't free the buffer afterwards.
|
|
It should only be used with borrowed `_UniffiRustBuffer` data.
|
|
"""
|
|
s = _UniffiRustBufferStream.from_rust_buffer(self)
|
|
yield s
|
|
if s.remaining() != 0:
|
|
raise RuntimeError("junk data left in buffer at end of read_with_stream")
|
|
|
|
class _UniffiForeignBytes(ctypes.Structure):
|
|
_fields_ = [
|
|
("len", ctypes.c_int32),
|
|
("data", ctypes.POINTER(ctypes.c_char)),
|
|
]
|
|
|
|
def __str__(self):
|
|
return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len])
|
|
|
|
|
|
class _UniffiRustBufferStream:
|
|
"""
|
|
Helper for structured reading of bytes from a _UniffiRustBuffer
|
|
"""
|
|
|
|
def __init__(self, data, len):
|
|
self.data = data
|
|
self.len = len
|
|
self.offset = 0
|
|
|
|
@classmethod
|
|
def from_rust_buffer(cls, buf):
|
|
return cls(buf.data, buf.len)
|
|
|
|
def remaining(self):
|
|
return self.len - self.offset
|
|
|
|
def _unpack_from(self, size, format):
|
|
if self.offset + size > self.len:
|
|
raise InternalError("read past end of rust buffer")
|
|
value = struct.unpack(format, self.data[self.offset:self.offset+size])[0]
|
|
self.offset += size
|
|
return value
|
|
|
|
def read(self, size):
|
|
if self.offset + size > self.len:
|
|
raise InternalError("read past end of rust buffer")
|
|
data = self.data[self.offset:self.offset+size]
|
|
self.offset += size
|
|
return data
|
|
|
|
def read_i8(self):
|
|
return self._unpack_from(1, ">b")
|
|
|
|
def read_u8(self):
|
|
return self._unpack_from(1, ">B")
|
|
|
|
def read_i16(self):
|
|
return self._unpack_from(2, ">h")
|
|
|
|
def read_u16(self):
|
|
return self._unpack_from(2, ">H")
|
|
|
|
def read_i32(self):
|
|
return self._unpack_from(4, ">i")
|
|
|
|
def read_u32(self):
|
|
return self._unpack_from(4, ">I")
|
|
|
|
def read_i64(self):
|
|
return self._unpack_from(8, ">q")
|
|
|
|
def read_u64(self):
|
|
return self._unpack_from(8, ">Q")
|
|
|
|
def read_float(self):
|
|
v = self._unpack_from(4, ">f")
|
|
return v
|
|
|
|
def read_double(self):
|
|
return self._unpack_from(8, ">d")
|
|
|
|
class _UniffiRustBufferBuilder:
|
|
"""
|
|
Helper for structured writing of bytes into a _UniffiRustBuffer.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.rbuf = _UniffiRustBuffer.alloc(16)
|
|
self.rbuf.len = 0
|
|
|
|
def finalize(self):
|
|
rbuf = self.rbuf
|
|
self.rbuf = None
|
|
return rbuf
|
|
|
|
def discard(self):
|
|
if self.rbuf is not None:
|
|
rbuf = self.finalize()
|
|
rbuf.free()
|
|
|
|
@contextlib.contextmanager
|
|
def _reserve(self, num_bytes):
|
|
if self.rbuf.len + num_bytes > self.rbuf.capacity:
|
|
self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes)
|
|
yield None
|
|
self.rbuf.len += num_bytes
|
|
|
|
def _pack_into(self, size, format, value):
|
|
with self._reserve(size):
|
|
# XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out.
|
|
for i, byte in enumerate(struct.pack(format, value)):
|
|
self.rbuf.data[self.rbuf.len + i] = byte
|
|
|
|
def write(self, value):
|
|
with self._reserve(len(value)):
|
|
for i, byte in enumerate(value):
|
|
self.rbuf.data[self.rbuf.len + i] = byte
|
|
|
|
def write_i8(self, v):
|
|
self._pack_into(1, ">b", v)
|
|
|
|
def write_u8(self, v):
|
|
self._pack_into(1, ">B", v)
|
|
|
|
def write_i16(self, v):
|
|
self._pack_into(2, ">h", v)
|
|
|
|
def write_u16(self, v):
|
|
self._pack_into(2, ">H", v)
|
|
|
|
def write_i32(self, v):
|
|
self._pack_into(4, ">i", v)
|
|
|
|
def write_u32(self, v):
|
|
self._pack_into(4, ">I", v)
|
|
|
|
def write_i64(self, v):
|
|
self._pack_into(8, ">q", v)
|
|
|
|
def write_u64(self, v):
|
|
self._pack_into(8, ">Q", v)
|
|
|
|
def write_float(self, v):
|
|
self._pack_into(4, ">f", v)
|
|
|
|
def write_double(self, v):
|
|
self._pack_into(8, ">d", v)
|
|
|
|
def write_c_size_t(self, v):
|
|
self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v)
|
|
# A handful of classes and functions to support the generated data structures.
|
|
# This would be a good candidate for isolating in its own ffi-support lib.
|
|
|
|
class InternalError(Exception):
|
|
pass
|
|
|
|
class _UniffiRustCallStatus(ctypes.Structure):
|
|
"""
|
|
Error runtime.
|
|
"""
|
|
_fields_ = [
|
|
("code", ctypes.c_int8),
|
|
("error_buf", _UniffiRustBuffer),
|
|
]
|
|
|
|
# These match the values from the uniffi::rustcalls module
|
|
CALL_SUCCESS = 0
|
|
CALL_ERROR = 1
|
|
CALL_UNEXPECTED_ERROR = 2
|
|
|
|
@staticmethod
|
|
def default():
|
|
return _UniffiRustCallStatus(code=_UniffiRustCallStatus.CALL_SUCCESS, error_buf=_UniffiRustBuffer.default())
|
|
|
|
def __str__(self):
|
|
if self.code == _UniffiRustCallStatus.CALL_SUCCESS:
|
|
return "_UniffiRustCallStatus(CALL_SUCCESS)"
|
|
elif self.code == _UniffiRustCallStatus.CALL_ERROR:
|
|
return "_UniffiRustCallStatus(CALL_ERROR)"
|
|
elif self.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
|
|
return "_UniffiRustCallStatus(CALL_UNEXPECTED_ERROR)"
|
|
else:
|
|
return "_UniffiRustCallStatus(<invalid code>)"
|
|
|
|
def _uniffi_rust_call(fn, *args):
|
|
# Call a rust function
|
|
return _uniffi_rust_call_with_error(None, fn, *args)
|
|
|
|
def _uniffi_rust_call_with_error(error_ffi_converter, fn, *args):
|
|
# Call a rust function and handle any errors
|
|
#
|
|
# This function is used for rust calls that return Result<> and therefore can set the CALL_ERROR status code.
|
|
# error_ffi_converter must be set to the _UniffiConverter for the error class that corresponds to the result.
|
|
call_status = _UniffiRustCallStatus.default()
|
|
|
|
args_with_error = args + (ctypes.byref(call_status),)
|
|
result = fn(*args_with_error)
|
|
_uniffi_check_call_status(error_ffi_converter, call_status)
|
|
return result
|
|
|
|
def _uniffi_check_call_status(error_ffi_converter, call_status):
|
|
if call_status.code == _UniffiRustCallStatus.CALL_SUCCESS:
|
|
pass
|
|
elif call_status.code == _UniffiRustCallStatus.CALL_ERROR:
|
|
if error_ffi_converter is None:
|
|
call_status.error_buf.free()
|
|
raise InternalError("_uniffi_rust_call_with_error: CALL_ERROR, but error_ffi_converter is None")
|
|
else:
|
|
raise error_ffi_converter.lift(call_status.error_buf)
|
|
elif call_status.code == _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR:
|
|
# When the rust code sees a panic, it tries to construct a _UniffiRustBuffer
|
|
# with the message. But if that code panics, then it just sends back
|
|
# an empty buffer.
|
|
if call_status.error_buf.len > 0:
|
|
msg = _UniffiConverterString.lift(call_status.error_buf)
|
|
else:
|
|
msg = "Unknown rust panic"
|
|
raise InternalError(msg)
|
|
else:
|
|
raise InternalError("Invalid _UniffiRustCallStatus code: {}".format(
|
|
call_status.code))
|
|
|
|
def _uniffi_trait_interface_call(call_status, make_call, write_return_value):
|
|
try:
|
|
return write_return_value(make_call())
|
|
except Exception as e:
|
|
call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
|
|
call_status.error_buf = _UniffiConverterString.lower(repr(e))
|
|
|
|
def _uniffi_trait_interface_call_with_error(call_status, make_call, write_return_value, error_type, lower_error):
|
|
try:
|
|
try:
|
|
return write_return_value(make_call())
|
|
except error_type as e:
|
|
call_status.code = _UniffiRustCallStatus.CALL_ERROR
|
|
call_status.error_buf = lower_error(e)
|
|
except Exception as e:
|
|
call_status.code = _UniffiRustCallStatus.CALL_UNEXPECTED_ERROR
|
|
call_status.error_buf = _UniffiConverterString.lower(repr(e))
|
|
class _UniffiHandleMap:
|
|
"""
|
|
A map where inserting, getting and removing data is synchronized with a lock.
|
|
"""
|
|
|
|
def __init__(self):
|
|
# type Handle = int
|
|
self._map = {} # type: Dict[Handle, Any]
|
|
self._lock = threading.Lock()
|
|
self._counter = itertools.count()
|
|
|
|
def insert(self, obj):
|
|
with self._lock:
|
|
handle = next(self._counter)
|
|
self._map[handle] = obj
|
|
return handle
|
|
|
|
def get(self, handle):
|
|
try:
|
|
with self._lock:
|
|
return self._map[handle]
|
|
except KeyError:
|
|
raise InternalError("_UniffiHandleMap.get: Invalid handle")
|
|
|
|
def remove(self, handle):
|
|
try:
|
|
with self._lock:
|
|
return self._map.pop(handle)
|
|
except KeyError:
|
|
raise InternalError("_UniffiHandleMap.remove: Invalid handle")
|
|
|
|
def __len__(self):
|
|
return len(self._map)
|
|
# Types conforming to `_UniffiConverterPrimitive` pass themselves directly over the FFI.
|
|
class _UniffiConverterPrimitive:
|
|
@classmethod
|
|
def lift(cls, value):
|
|
return value
|
|
|
|
@classmethod
|
|
def lower(cls, value):
|
|
return value
|
|
|
|
class _UniffiConverterPrimitiveInt(_UniffiConverterPrimitive):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
try:
|
|
value = value.__index__()
|
|
except Exception:
|
|
raise TypeError("'{}' object cannot be interpreted as an integer".format(type(value).__name__))
|
|
if not isinstance(value, int):
|
|
raise TypeError("__index__ returned non-int (type {})".format(type(value).__name__))
|
|
if not cls.VALUE_MIN <= value < cls.VALUE_MAX:
|
|
raise ValueError("{} requires {} <= value < {}".format(cls.CLASS_NAME, cls.VALUE_MIN, cls.VALUE_MAX))
|
|
|
|
class _UniffiConverterPrimitiveFloat(_UniffiConverterPrimitive):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
try:
|
|
value = value.__float__()
|
|
except Exception:
|
|
raise TypeError("must be real number, not {}".format(type(value).__name__))
|
|
if not isinstance(value, float):
|
|
raise TypeError("__float__ returned non-float (type {})".format(type(value).__name__))
|
|
|
|
# Helper class for wrapper types that will always go through a _UniffiRustBuffer.
|
|
# Classes should inherit from this and implement the `read` and `write` static methods.
|
|
class _UniffiConverterRustBuffer:
|
|
@classmethod
|
|
def lift(cls, rbuf):
|
|
with rbuf.consume_with_stream() as stream:
|
|
return cls.read(stream)
|
|
|
|
@classmethod
|
|
def lower(cls, value):
|
|
with _UniffiRustBuffer.alloc_with_builder() as builder:
|
|
cls.write(value, builder)
|
|
return builder.finalize()
|
|
|
|
# Contains loading, initialization code, and the FFI Function declarations.
|
|
# Define some ctypes FFI types that we use in the library
|
|
|
|
"""
|
|
Function pointer for a Rust task, which a callback function that takes a opaque pointer
|
|
"""
|
|
_UNIFFI_RUST_TASK = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int8)
|
|
|
|
def _uniffi_future_callback_t(return_type):
|
|
"""
|
|
Factory function to create callback function types for async functions
|
|
"""
|
|
return ctypes.CFUNCTYPE(None, ctypes.c_uint64, return_type, _UniffiRustCallStatus)
|
|
|
|
def _uniffi_load_indirect():
|
|
"""
|
|
This is how we find and load the dynamic library provided by the component.
|
|
For now we just look it up by name.
|
|
"""
|
|
if sys.platform == "darwin":
|
|
libname = "lib{}.dylib"
|
|
elif sys.platform.startswith("win"):
|
|
# As of python3.8, ctypes does not seem to search $PATH when loading DLLs.
|
|
# We could use `os.add_dll_directory` to configure the search path, but
|
|
# it doesn't feel right to mess with application-wide settings. Let's
|
|
# assume that the `.dll` is next to the `.py` file and load by full path.
|
|
libname = os.path.join(
|
|
os.path.dirname(__file__),
|
|
"{}.dll",
|
|
)
|
|
else:
|
|
# Anything else must be an ELF platform - Linux, *BSD, Solaris/illumos
|
|
libname = "lib{}.so"
|
|
|
|
libname = libname.format("goose_llm")
|
|
path = os.path.join(os.path.dirname(__file__), libname)
|
|
lib = ctypes.cdll.LoadLibrary(path)
|
|
return lib
|
|
|
|
def _uniffi_check_contract_api_version(lib):
|
|
# Get the bindings contract version from our ComponentInterface
|
|
bindings_contract_version = 29
|
|
# Get the scaffolding contract version by calling the into the dylib
|
|
scaffolding_contract_version = lib.ffi_goose_llm_uniffi_contract_version()
|
|
if bindings_contract_version != scaffolding_contract_version:
|
|
raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
|
|
|
|
def _uniffi_check_api_checksums(lib):
|
|
if lib.uniffi_goose_llm_checksum_func_completion() != 47457:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
if lib.uniffi_goose_llm_checksum_func_create_completion_request() != 51008:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
if lib.uniffi_goose_llm_checksum_func_create_tool_config() != 22809:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
if lib.uniffi_goose_llm_checksum_func_generate_session_name() != 9810:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
if lib.uniffi_goose_llm_checksum_func_generate_tooltip() != 15466:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
if lib.uniffi_goose_llm_checksum_func_print_messages() != 30278:
|
|
raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
|
|
|
|
# A ctypes library to expose the extern-C FFI definitions.
|
|
# This is an implementation detail which will be called internally by the public API.
|
|
|
|
_UniffiLib = _uniffi_load_indirect()
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK = ctypes.CFUNCTYPE(None,ctypes.c_uint64,ctypes.c_int8,
|
|
)
|
|
_UNIFFI_FOREIGN_FUTURE_FREE = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
|
|
)
|
|
_UNIFFI_CALLBACK_INTERFACE_FREE = ctypes.CFUNCTYPE(None,ctypes.c_uint64,
|
|
)
|
|
class _UniffiForeignFuture(ctypes.Structure):
|
|
_fields_ = [
|
|
("handle", ctypes.c_uint64),
|
|
("free", _UNIFFI_FOREIGN_FUTURE_FREE),
|
|
]
|
|
class _UniffiForeignFutureStructU8(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint8),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU8,
|
|
)
|
|
class _UniffiForeignFutureStructI8(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int8),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I8 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI8,
|
|
)
|
|
class _UniffiForeignFutureStructU16(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint16),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U16 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU16,
|
|
)
|
|
class _UniffiForeignFutureStructI16(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int16),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I16 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI16,
|
|
)
|
|
class _UniffiForeignFutureStructU32(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint32),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U32 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU32,
|
|
)
|
|
class _UniffiForeignFutureStructI32(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int32),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I32 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI32,
|
|
)
|
|
class _UniffiForeignFutureStructU64(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_uint64),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_U64 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructU64,
|
|
)
|
|
class _UniffiForeignFutureStructI64(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_int64),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_I64 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructI64,
|
|
)
|
|
class _UniffiForeignFutureStructF32(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_float),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_F32 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructF32,
|
|
)
|
|
class _UniffiForeignFutureStructF64(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_double),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_F64 = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructF64,
|
|
)
|
|
class _UniffiForeignFutureStructPointer(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", ctypes.c_void_p),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_POINTER = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructPointer,
|
|
)
|
|
class _UniffiForeignFutureStructRustBuffer(ctypes.Structure):
|
|
_fields_ = [
|
|
("return_value", _UniffiRustBuffer),
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_RUST_BUFFER = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructRustBuffer,
|
|
)
|
|
class _UniffiForeignFutureStructVoid(ctypes.Structure):
|
|
_fields_ = [
|
|
("call_status", _UniffiRustCallStatus),
|
|
]
|
|
_UNIFFI_FOREIGN_FUTURE_COMPLETE_VOID = ctypes.CFUNCTYPE(None,ctypes.c_uint64,_UniffiForeignFutureStructVoid,
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_completion.argtypes = (
|
|
_UniffiRustBuffer,
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_completion.restype = ctypes.c_uint64
|
|
_UniffiLib.uniffi_goose_llm_fn_func_create_completion_request.argtypes = (
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_create_completion_request.restype = _UniffiRustBuffer
|
|
_UniffiLib.uniffi_goose_llm_fn_func_create_tool_config.argtypes = (
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_create_tool_config.restype = _UniffiRustBuffer
|
|
_UniffiLib.uniffi_goose_llm_fn_func_generate_session_name.argtypes = (
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_generate_session_name.restype = ctypes.c_uint64
|
|
_UniffiLib.uniffi_goose_llm_fn_func_generate_tooltip.argtypes = (
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
_UniffiRustBuffer,
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_generate_tooltip.restype = ctypes.c_uint64
|
|
_UniffiLib.uniffi_goose_llm_fn_func_print_messages.argtypes = (
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_fn_func_print_messages.restype = None
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_alloc.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_alloc.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_from_bytes.argtypes = (
|
|
_UniffiForeignBytes,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_from_bytes.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_free.argtypes = (
|
|
_UniffiRustBuffer,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_free.restype = None
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_reserve.argtypes = (
|
|
_UniffiRustBuffer,
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rustbuffer_reserve.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u8.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u8.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u8.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u8.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u8.restype = ctypes.c_uint8
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i8.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i8.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i8.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i8.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i8.restype = ctypes.c_int8
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u16.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u16.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u16.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u16.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u16.restype = ctypes.c_uint16
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i16.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i16.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i16.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i16.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i16.restype = ctypes.c_int16
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u32.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u32.restype = ctypes.c_uint32
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i32.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i32.restype = ctypes.c_int32
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_u64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_u64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_u64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u64.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_u64.restype = ctypes.c_uint64
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_i64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_i64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_i64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i64.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_i64.restype = ctypes.c_int64
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_f32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_f32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_f32.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_f32.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_f32.restype = ctypes.c_float
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_f64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_f64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_f64.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_f64.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_f64.restype = ctypes.c_double
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_pointer.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_pointer.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_pointer.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_pointer.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_pointer.restype = ctypes.c_void_p
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_rust_buffer.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_rust_buffer.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_rust_buffer.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_rust_buffer.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_rust_buffer.restype = _UniffiRustBuffer
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK,
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_void.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_cancel_void.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_void.restype = None
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_void.argtypes = (
|
|
ctypes.c_uint64,
|
|
ctypes.POINTER(_UniffiRustCallStatus),
|
|
)
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_void.restype = None
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_completion.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_completion.restype = ctypes.c_uint16
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_create_completion_request.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_create_completion_request.restype = ctypes.c_uint16
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_create_tool_config.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_create_tool_config.restype = ctypes.c_uint16
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_generate_session_name.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_generate_session_name.restype = ctypes.c_uint16
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_generate_tooltip.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_generate_tooltip.restype = ctypes.c_uint16
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_print_messages.argtypes = (
|
|
)
|
|
_UniffiLib.uniffi_goose_llm_checksum_func_print_messages.restype = ctypes.c_uint16
|
|
_UniffiLib.ffi_goose_llm_uniffi_contract_version.argtypes = (
|
|
)
|
|
_UniffiLib.ffi_goose_llm_uniffi_contract_version.restype = ctypes.c_uint32
|
|
|
|
_uniffi_check_contract_api_version(_UniffiLib)
|
|
# _uniffi_check_api_checksums(_UniffiLib)
|
|
|
|
# Public interface members begin here.
|
|
|
|
|
|
class _UniffiConverterUInt32(_UniffiConverterPrimitiveInt):
|
|
CLASS_NAME = "u32"
|
|
VALUE_MIN = 0
|
|
VALUE_MAX = 2**32
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return buf.read_u32()
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
buf.write_u32(value)
|
|
|
|
class _UniffiConverterInt32(_UniffiConverterPrimitiveInt):
|
|
CLASS_NAME = "i32"
|
|
VALUE_MIN = -2**31
|
|
VALUE_MAX = 2**31
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return buf.read_i32()
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
buf.write_i32(value)
|
|
|
|
class _UniffiConverterInt64(_UniffiConverterPrimitiveInt):
|
|
CLASS_NAME = "i64"
|
|
VALUE_MIN = -2**63
|
|
VALUE_MAX = 2**63
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return buf.read_i64()
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
buf.write_i64(value)
|
|
|
|
class _UniffiConverterFloat(_UniffiConverterPrimitiveFloat):
|
|
@staticmethod
|
|
def read(buf):
|
|
return buf.read_float()
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
buf.write_float(value)
|
|
|
|
class _UniffiConverterDouble(_UniffiConverterPrimitiveFloat):
|
|
@staticmethod
|
|
def read(buf):
|
|
return buf.read_double()
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
buf.write_double(value)
|
|
|
|
class _UniffiConverterString:
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError("argument must be str, not {}".format(type(value).__name__))
|
|
return value
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
size = buf.read_i32()
|
|
if size < 0:
|
|
raise InternalError("Unexpected negative string length")
|
|
utf8_bytes = buf.read(size)
|
|
return utf8_bytes.decode("utf-8")
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
utf8_bytes = value.encode("utf-8")
|
|
buf.write_i32(len(utf8_bytes))
|
|
buf.write(utf8_bytes)
|
|
|
|
@staticmethod
|
|
def lift(buf):
|
|
with buf.consume_with_stream() as stream:
|
|
return stream.read(stream.remaining()).decode("utf-8")
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
with _UniffiRustBuffer.alloc_with_builder() as builder:
|
|
builder.write(value.encode("utf-8"))
|
|
return builder.finalize()
|
|
|
|
|
|
class CompletionResponse:
|
|
message: "Message"
|
|
model: "str"
|
|
usage: "Usage"
|
|
runtime_metrics: "RuntimeMetrics"
|
|
def __init__(self, *, message: "Message", model: "str", usage: "Usage", runtime_metrics: "RuntimeMetrics"):
|
|
self.message = message
|
|
self.model = model
|
|
self.usage = usage
|
|
self.runtime_metrics = runtime_metrics
|
|
|
|
def __str__(self):
|
|
return "CompletionResponse(message={}, model={}, usage={}, runtime_metrics={})".format(self.message, self.model, self.usage, self.runtime_metrics)
|
|
|
|
def __eq__(self, other):
|
|
if self.message != other.message:
|
|
return False
|
|
if self.model != other.model:
|
|
return False
|
|
if self.usage != other.usage:
|
|
return False
|
|
if self.runtime_metrics != other.runtime_metrics:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeCompletionResponse(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return CompletionResponse(
|
|
message=_UniffiConverterTypeMessage.read(buf),
|
|
model=_UniffiConverterString.read(buf),
|
|
usage=_UniffiConverterTypeUsage.read(buf),
|
|
runtime_metrics=_UniffiConverterTypeRuntimeMetrics.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterTypeMessage.check_lower(value.message)
|
|
_UniffiConverterString.check_lower(value.model)
|
|
_UniffiConverterTypeUsage.check_lower(value.usage)
|
|
_UniffiConverterTypeRuntimeMetrics.check_lower(value.runtime_metrics)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterTypeMessage.write(value.message, buf)
|
|
_UniffiConverterString.write(value.model, buf)
|
|
_UniffiConverterTypeUsage.write(value.usage, buf)
|
|
_UniffiConverterTypeRuntimeMetrics.write(value.runtime_metrics, buf)
|
|
|
|
|
|
class ExtensionConfig:
|
|
name: "str"
|
|
instructions: "typing.Optional[str]"
|
|
tools: "typing.List[ToolConfig]"
|
|
def __init__(self, *, name: "str", instructions: "typing.Optional[str]", tools: "typing.List[ToolConfig]"):
|
|
self.name = name
|
|
self.instructions = instructions
|
|
self.tools = tools
|
|
|
|
def __str__(self):
|
|
return "ExtensionConfig(name={}, instructions={}, tools={})".format(self.name, self.instructions, self.tools)
|
|
|
|
def __eq__(self, other):
|
|
if self.name != other.name:
|
|
return False
|
|
if self.instructions != other.instructions:
|
|
return False
|
|
if self.tools != other.tools:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeExtensionConfig(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ExtensionConfig(
|
|
name=_UniffiConverterString.read(buf),
|
|
instructions=_UniffiConverterOptionalString.read(buf),
|
|
tools=_UniffiConverterSequenceTypeToolConfig.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.name)
|
|
_UniffiConverterOptionalString.check_lower(value.instructions)
|
|
_UniffiConverterSequenceTypeToolConfig.check_lower(value.tools)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.name, buf)
|
|
_UniffiConverterOptionalString.write(value.instructions, buf)
|
|
_UniffiConverterSequenceTypeToolConfig.write(value.tools, buf)
|
|
|
|
|
|
class ImageContent:
|
|
data: "str"
|
|
mime_type: "str"
|
|
def __init__(self, *, data: "str", mime_type: "str"):
|
|
self.data = data
|
|
self.mime_type = mime_type
|
|
|
|
def __str__(self):
|
|
return "ImageContent(data={}, mime_type={})".format(self.data, self.mime_type)
|
|
|
|
def __eq__(self, other):
|
|
if self.data != other.data:
|
|
return False
|
|
if self.mime_type != other.mime_type:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeImageContent(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ImageContent(
|
|
data=_UniffiConverterString.read(buf),
|
|
mime_type=_UniffiConverterString.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.data)
|
|
_UniffiConverterString.check_lower(value.mime_type)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.data, buf)
|
|
_UniffiConverterString.write(value.mime_type, buf)
|
|
|
|
|
|
class Message:
|
|
"""
|
|
A message to or from an LLM
|
|
"""
|
|
|
|
role: "Role"
|
|
created: "int"
|
|
content: "Contents"
|
|
def __init__(self, *, role: "Role", created: "int", content: "Contents"):
|
|
self.role = role
|
|
self.created = created
|
|
self.content = content
|
|
|
|
def __str__(self):
|
|
return "Message(role={}, created={}, content={})".format(self.role, self.created, self.content)
|
|
|
|
def __eq__(self, other):
|
|
if self.role != other.role:
|
|
return False
|
|
if self.created != other.created:
|
|
return False
|
|
if self.content != other.content:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeMessage(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return Message(
|
|
role=_UniffiConverterTypeRole.read(buf),
|
|
created=_UniffiConverterInt64.read(buf),
|
|
content=_UniffiConverterTypeContents.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterTypeRole.check_lower(value.role)
|
|
_UniffiConverterInt64.check_lower(value.created)
|
|
_UniffiConverterTypeContents.check_lower(value.content)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterTypeRole.write(value.role, buf)
|
|
_UniffiConverterInt64.write(value.created, buf)
|
|
_UniffiConverterTypeContents.write(value.content, buf)
|
|
|
|
|
|
class ModelConfig:
|
|
"""
|
|
Configuration for model-specific settings and limits
|
|
"""
|
|
|
|
model_name: "str"
|
|
"""
|
|
The name of the model to use
|
|
"""
|
|
|
|
context_limit: "typing.Optional[int]"
|
|
"""
|
|
Optional explicit context limit that overrides any defaults
|
|
"""
|
|
|
|
temperature: "typing.Optional[float]"
|
|
"""
|
|
Optional temperature setting (0.0 - 1.0)
|
|
"""
|
|
|
|
max_tokens: "typing.Optional[int]"
|
|
"""
|
|
Optional maximum tokens to generate
|
|
"""
|
|
|
|
def __init__(self, *, model_name: "str", context_limit: "typing.Optional[int]", temperature: "typing.Optional[float]", max_tokens: "typing.Optional[int]"):
|
|
self.model_name = model_name
|
|
self.context_limit = context_limit
|
|
self.temperature = temperature
|
|
self.max_tokens = max_tokens
|
|
|
|
def __str__(self):
|
|
return "ModelConfig(model_name={}, context_limit={}, temperature={}, max_tokens={})".format(self.model_name, self.context_limit, self.temperature, self.max_tokens)
|
|
|
|
def __eq__(self, other):
|
|
if self.model_name != other.model_name:
|
|
return False
|
|
if self.context_limit != other.context_limit:
|
|
return False
|
|
if self.temperature != other.temperature:
|
|
return False
|
|
if self.max_tokens != other.max_tokens:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeModelConfig(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ModelConfig(
|
|
model_name=_UniffiConverterString.read(buf),
|
|
context_limit=_UniffiConverterOptionalUInt32.read(buf),
|
|
temperature=_UniffiConverterOptionalFloat.read(buf),
|
|
max_tokens=_UniffiConverterOptionalInt32.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.model_name)
|
|
_UniffiConverterOptionalUInt32.check_lower(value.context_limit)
|
|
_UniffiConverterOptionalFloat.check_lower(value.temperature)
|
|
_UniffiConverterOptionalInt32.check_lower(value.max_tokens)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.model_name, buf)
|
|
_UniffiConverterOptionalUInt32.write(value.context_limit, buf)
|
|
_UniffiConverterOptionalFloat.write(value.temperature, buf)
|
|
_UniffiConverterOptionalInt32.write(value.max_tokens, buf)
|
|
|
|
|
|
class ProviderCompleteResponse:
|
|
message: "Message"
|
|
model: "str"
|
|
usage: "Usage"
|
|
def __init__(self, *, message: "Message", model: "str", usage: "Usage"):
|
|
self.message = message
|
|
self.model = model
|
|
self.usage = usage
|
|
|
|
def __str__(self):
|
|
return "ProviderCompleteResponse(message={}, model={}, usage={})".format(self.message, self.model, self.usage)
|
|
|
|
def __eq__(self, other):
|
|
if self.message != other.message:
|
|
return False
|
|
if self.model != other.model:
|
|
return False
|
|
if self.usage != other.usage:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeProviderCompleteResponse(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ProviderCompleteResponse(
|
|
message=_UniffiConverterTypeMessage.read(buf),
|
|
model=_UniffiConverterString.read(buf),
|
|
usage=_UniffiConverterTypeUsage.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterTypeMessage.check_lower(value.message)
|
|
_UniffiConverterString.check_lower(value.model)
|
|
_UniffiConverterTypeUsage.check_lower(value.usage)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterTypeMessage.write(value.message, buf)
|
|
_UniffiConverterString.write(value.model, buf)
|
|
_UniffiConverterTypeUsage.write(value.usage, buf)
|
|
|
|
|
|
class RedactedThinkingContent:
|
|
data: "str"
|
|
def __init__(self, *, data: "str"):
|
|
self.data = data
|
|
|
|
def __str__(self):
|
|
return "RedactedThinkingContent(data={})".format(self.data)
|
|
|
|
def __eq__(self, other):
|
|
if self.data != other.data:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeRedactedThinkingContent(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return RedactedThinkingContent(
|
|
data=_UniffiConverterString.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.data)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.data, buf)
|
|
|
|
|
|
class RuntimeMetrics:
|
|
total_time_sec: "float"
|
|
total_time_sec_provider: "float"
|
|
tokens_per_second: "typing.Optional[float]"
|
|
def __init__(self, *, total_time_sec: "float", total_time_sec_provider: "float", tokens_per_second: "typing.Optional[float]"):
|
|
self.total_time_sec = total_time_sec
|
|
self.total_time_sec_provider = total_time_sec_provider
|
|
self.tokens_per_second = tokens_per_second
|
|
|
|
def __str__(self):
|
|
return "RuntimeMetrics(total_time_sec={}, total_time_sec_provider={}, tokens_per_second={})".format(self.total_time_sec, self.total_time_sec_provider, self.tokens_per_second)
|
|
|
|
def __eq__(self, other):
|
|
if self.total_time_sec != other.total_time_sec:
|
|
return False
|
|
if self.total_time_sec_provider != other.total_time_sec_provider:
|
|
return False
|
|
if self.tokens_per_second != other.tokens_per_second:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeRuntimeMetrics(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return RuntimeMetrics(
|
|
total_time_sec=_UniffiConverterFloat.read(buf),
|
|
total_time_sec_provider=_UniffiConverterFloat.read(buf),
|
|
tokens_per_second=_UniffiConverterOptionalDouble.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterFloat.check_lower(value.total_time_sec)
|
|
_UniffiConverterFloat.check_lower(value.total_time_sec_provider)
|
|
_UniffiConverterOptionalDouble.check_lower(value.tokens_per_second)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterFloat.write(value.total_time_sec, buf)
|
|
_UniffiConverterFloat.write(value.total_time_sec_provider, buf)
|
|
_UniffiConverterOptionalDouble.write(value.tokens_per_second, buf)
|
|
|
|
|
|
class TextContent:
|
|
text: "str"
|
|
def __init__(self, *, text: "str"):
|
|
self.text = text
|
|
|
|
def __str__(self):
|
|
return "TextContent(text={})".format(self.text)
|
|
|
|
def __eq__(self, other):
|
|
if self.text != other.text:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeTextContent(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return TextContent(
|
|
text=_UniffiConverterString.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.text)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.text, buf)
|
|
|
|
|
|
class ThinkingContent:
|
|
thinking: "str"
|
|
signature: "str"
|
|
def __init__(self, *, thinking: "str", signature: "str"):
|
|
self.thinking = thinking
|
|
self.signature = signature
|
|
|
|
def __str__(self):
|
|
return "ThinkingContent(thinking={}, signature={})".format(self.thinking, self.signature)
|
|
|
|
def __eq__(self, other):
|
|
if self.thinking != other.thinking:
|
|
return False
|
|
if self.signature != other.signature:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeThinkingContent(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ThinkingContent(
|
|
thinking=_UniffiConverterString.read(buf),
|
|
signature=_UniffiConverterString.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.thinking)
|
|
_UniffiConverterString.check_lower(value.signature)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.thinking, buf)
|
|
_UniffiConverterString.write(value.signature, buf)
|
|
|
|
|
|
class ToolRequest:
|
|
id: "str"
|
|
tool_call: "ToolRequestToolCall"
|
|
def __init__(self, *, id: "str", tool_call: "ToolRequestToolCall"):
|
|
self.id = id
|
|
self.tool_call = tool_call
|
|
|
|
def __str__(self):
|
|
return "ToolRequest(id={}, tool_call={})".format(self.id, self.tool_call)
|
|
|
|
def __eq__(self, other):
|
|
if self.id != other.id:
|
|
return False
|
|
if self.tool_call != other.tool_call:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeToolRequest(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ToolRequest(
|
|
id=_UniffiConverterString.read(buf),
|
|
tool_call=_UniffiConverterTypeToolRequestToolCall.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.id)
|
|
_UniffiConverterTypeToolRequestToolCall.check_lower(value.tool_call)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.id, buf)
|
|
_UniffiConverterTypeToolRequestToolCall.write(value.tool_call, buf)
|
|
|
|
|
|
class ToolResponse:
|
|
id: "str"
|
|
tool_result: "ToolResponseToolResult"
|
|
def __init__(self, *, id: "str", tool_result: "ToolResponseToolResult"):
|
|
self.id = id
|
|
self.tool_result = tool_result
|
|
|
|
def __str__(self):
|
|
return "ToolResponse(id={}, tool_result={})".format(self.id, self.tool_result)
|
|
|
|
def __eq__(self, other):
|
|
if self.id != other.id:
|
|
return False
|
|
if self.tool_result != other.tool_result:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeToolResponse(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return ToolResponse(
|
|
id=_UniffiConverterString.read(buf),
|
|
tool_result=_UniffiConverterTypeToolResponseToolResult.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterString.check_lower(value.id)
|
|
_UniffiConverterTypeToolResponseToolResult.check_lower(value.tool_result)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value.id, buf)
|
|
_UniffiConverterTypeToolResponseToolResult.write(value.tool_result, buf)
|
|
|
|
|
|
class Usage:
|
|
input_tokens: "typing.Optional[int]"
|
|
output_tokens: "typing.Optional[int]"
|
|
total_tokens: "typing.Optional[int]"
|
|
def __init__(self, *, input_tokens: "typing.Optional[int]", output_tokens: "typing.Optional[int]", total_tokens: "typing.Optional[int]"):
|
|
self.input_tokens = input_tokens
|
|
self.output_tokens = output_tokens
|
|
self.total_tokens = total_tokens
|
|
|
|
def __str__(self):
|
|
return "Usage(input_tokens={}, output_tokens={}, total_tokens={})".format(self.input_tokens, self.output_tokens, self.total_tokens)
|
|
|
|
def __eq__(self, other):
|
|
if self.input_tokens != other.input_tokens:
|
|
return False
|
|
if self.output_tokens != other.output_tokens:
|
|
return False
|
|
if self.total_tokens != other.total_tokens:
|
|
return False
|
|
return True
|
|
|
|
class _UniffiConverterTypeUsage(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
return Usage(
|
|
input_tokens=_UniffiConverterOptionalInt32.read(buf),
|
|
output_tokens=_UniffiConverterOptionalInt32.read(buf),
|
|
total_tokens=_UniffiConverterOptionalInt32.read(buf),
|
|
)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
_UniffiConverterOptionalInt32.check_lower(value.input_tokens)
|
|
_UniffiConverterOptionalInt32.check_lower(value.output_tokens)
|
|
_UniffiConverterOptionalInt32.check_lower(value.total_tokens)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterOptionalInt32.write(value.input_tokens, buf)
|
|
_UniffiConverterOptionalInt32.write(value.output_tokens, buf)
|
|
_UniffiConverterOptionalInt32.write(value.total_tokens, buf)
|
|
|
|
|
|
# CompletionError
|
|
# We want to define each variant as a nested class that's also a subclass,
|
|
# which is tricky in Python. To accomplish this we're going to create each
|
|
# class separately, then manually add the child classes to the base class's
|
|
# __dict__. All of this happens in dummy class to avoid polluting the module
|
|
# namespace.
|
|
class CompletionError(Exception):
|
|
pass
|
|
|
|
_UniffiTempCompletionError = CompletionError
|
|
|
|
class CompletionError: # type: ignore
|
|
class UnknownProvider(_UniffiTempCompletionError):
|
|
|
|
def __repr__(self):
|
|
return "CompletionError.UnknownProvider({})".format(repr(str(self)))
|
|
_UniffiTempCompletionError.UnknownProvider = UnknownProvider # type: ignore
|
|
class Provider(_UniffiTempCompletionError):
|
|
|
|
def __repr__(self):
|
|
return "CompletionError.Provider({})".format(repr(str(self)))
|
|
_UniffiTempCompletionError.Provider = Provider # type: ignore
|
|
class Template(_UniffiTempCompletionError):
|
|
|
|
def __repr__(self):
|
|
return "CompletionError.Template({})".format(repr(str(self)))
|
|
_UniffiTempCompletionError.Template = Template # type: ignore
|
|
class Json(_UniffiTempCompletionError):
|
|
|
|
def __repr__(self):
|
|
return "CompletionError.Json({})".format(repr(str(self)))
|
|
_UniffiTempCompletionError.Json = Json # type: ignore
|
|
class ToolNotFound(_UniffiTempCompletionError):
|
|
|
|
def __repr__(self):
|
|
return "CompletionError.ToolNotFound({})".format(repr(str(self)))
|
|
_UniffiTempCompletionError.ToolNotFound = ToolNotFound # type: ignore
|
|
|
|
CompletionError = _UniffiTempCompletionError # type: ignore
|
|
del _UniffiTempCompletionError
|
|
|
|
|
|
class _UniffiConverterTypeCompletionError(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return CompletionError.UnknownProvider(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 2:
|
|
return CompletionError.Provider(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 3:
|
|
return CompletionError.Template(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 4:
|
|
return CompletionError.Json(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 5:
|
|
return CompletionError.ToolNotFound(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if isinstance(value, CompletionError.UnknownProvider):
|
|
return
|
|
if isinstance(value, CompletionError.Provider):
|
|
return
|
|
if isinstance(value, CompletionError.Template):
|
|
return
|
|
if isinstance(value, CompletionError.Json):
|
|
return
|
|
if isinstance(value, CompletionError.ToolNotFound):
|
|
return
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if isinstance(value, CompletionError.UnknownProvider):
|
|
buf.write_i32(1)
|
|
if isinstance(value, CompletionError.Provider):
|
|
buf.write_i32(2)
|
|
if isinstance(value, CompletionError.Template):
|
|
buf.write_i32(3)
|
|
if isinstance(value, CompletionError.Json):
|
|
buf.write_i32(4)
|
|
if isinstance(value, CompletionError.ToolNotFound):
|
|
buf.write_i32(5)
|
|
|
|
|
|
|
|
|
|
|
|
class Content:
|
|
def __init__(self):
|
|
raise RuntimeError("Content cannot be instantiated directly")
|
|
|
|
# Each enum variant is a nested class of the enum itself.
|
|
class TEXT:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"Content.TEXT{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_TEXT():
|
|
return False
|
|
return self._values == other._values
|
|
class IMAGE:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"Content.IMAGE{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_IMAGE():
|
|
return False
|
|
return self._values == other._values
|
|
|
|
|
|
# For each variant, we have `is_NAME` and `is_name` methods for easily checking
|
|
# whether an instance is that variant.
|
|
def is_TEXT(self) -> bool:
|
|
return isinstance(self, Content.TEXT)
|
|
def is_text(self) -> bool:
|
|
return isinstance(self, Content.TEXT)
|
|
def is_IMAGE(self) -> bool:
|
|
return isinstance(self, Content.IMAGE)
|
|
def is_image(self) -> bool:
|
|
return isinstance(self, Content.IMAGE)
|
|
|
|
|
|
# Now, a little trick - we make each nested variant class be a subclass of the main
|
|
# enum class, so that method calls and instance checks etc will work intuitively.
|
|
# We might be able to do this a little more neatly with a metaclass, but this'll do.
|
|
Content.TEXT = type("Content.TEXT", (Content.TEXT, Content,), {}) # type: ignore
|
|
Content.IMAGE = type("Content.IMAGE", (Content.IMAGE, Content,), {}) # type: ignore
|
|
|
|
|
|
|
|
|
|
class _UniffiConverterTypeContent(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return Content.TEXT(
|
|
_UniffiConverterTypeTextContent.read(buf),
|
|
)
|
|
if variant == 2:
|
|
return Content.IMAGE(
|
|
_UniffiConverterTypeImageContent.read(buf),
|
|
)
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if value.is_TEXT():
|
|
_UniffiConverterTypeTextContent.check_lower(value._values[0])
|
|
return
|
|
if value.is_IMAGE():
|
|
_UniffiConverterTypeImageContent.check_lower(value._values[0])
|
|
return
|
|
raise ValueError(value)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if value.is_TEXT():
|
|
buf.write_i32(1)
|
|
_UniffiConverterTypeTextContent.write(value._values[0], buf)
|
|
if value.is_IMAGE():
|
|
buf.write_i32(2)
|
|
_UniffiConverterTypeImageContent.write(value._values[0], buf)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class MessageContent:
|
|
"""
|
|
Content passed inside a message, which can be both simple content and tool content
|
|
"""
|
|
|
|
def __init__(self):
|
|
raise RuntimeError("MessageContent cannot be instantiated directly")
|
|
|
|
# Each enum variant is a nested class of the enum itself.
|
|
class TEXT:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"MessageContent.TEXT{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_TEXT():
|
|
return False
|
|
return self._values == other._values
|
|
class IMAGE:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"MessageContent.IMAGE{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_IMAGE():
|
|
return False
|
|
return self._values == other._values
|
|
class TOOL_REQ:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"MessageContent.TOOL_REQ{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_TOOL_REQ():
|
|
return False
|
|
return self._values == other._values
|
|
class TOOL_RESP:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"MessageContent.TOOL_RESP{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_TOOL_RESP():
|
|
return False
|
|
return self._values == other._values
|
|
class THINKING:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"MessageContent.THINKING{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_THINKING():
|
|
return False
|
|
return self._values == other._values
|
|
class REDACTED_THINKING:
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __str__(self):
|
|
return f"MessageContent.REDACTED_THINKING{self._values!r}"
|
|
|
|
def __eq__(self, other):
|
|
if not other.is_REDACTED_THINKING():
|
|
return False
|
|
return self._values == other._values
|
|
|
|
|
|
# For each variant, we have `is_NAME` and `is_name` methods for easily checking
|
|
# whether an instance is that variant.
|
|
def is_TEXT(self) -> bool:
|
|
return isinstance(self, MessageContent.TEXT)
|
|
def is_text(self) -> bool:
|
|
return isinstance(self, MessageContent.TEXT)
|
|
def is_IMAGE(self) -> bool:
|
|
return isinstance(self, MessageContent.IMAGE)
|
|
def is_image(self) -> bool:
|
|
return isinstance(self, MessageContent.IMAGE)
|
|
def is_TOOL_REQ(self) -> bool:
|
|
return isinstance(self, MessageContent.TOOL_REQ)
|
|
def is_tool_req(self) -> bool:
|
|
return isinstance(self, MessageContent.TOOL_REQ)
|
|
def is_TOOL_RESP(self) -> bool:
|
|
return isinstance(self, MessageContent.TOOL_RESP)
|
|
def is_tool_resp(self) -> bool:
|
|
return isinstance(self, MessageContent.TOOL_RESP)
|
|
def is_THINKING(self) -> bool:
|
|
return isinstance(self, MessageContent.THINKING)
|
|
def is_thinking(self) -> bool:
|
|
return isinstance(self, MessageContent.THINKING)
|
|
def is_REDACTED_THINKING(self) -> bool:
|
|
return isinstance(self, MessageContent.REDACTED_THINKING)
|
|
def is_redacted_thinking(self) -> bool:
|
|
return isinstance(self, MessageContent.REDACTED_THINKING)
|
|
|
|
|
|
# Now, a little trick - we make each nested variant class be a subclass of the main
|
|
# enum class, so that method calls and instance checks etc will work intuitively.
|
|
# We might be able to do this a little more neatly with a metaclass, but this'll do.
|
|
MessageContent.TEXT = type("MessageContent.TEXT", (MessageContent.TEXT, MessageContent,), {}) # type: ignore
|
|
MessageContent.IMAGE = type("MessageContent.IMAGE", (MessageContent.IMAGE, MessageContent,), {}) # type: ignore
|
|
MessageContent.TOOL_REQ = type("MessageContent.TOOL_REQ", (MessageContent.TOOL_REQ, MessageContent,), {}) # type: ignore
|
|
MessageContent.TOOL_RESP = type("MessageContent.TOOL_RESP", (MessageContent.TOOL_RESP, MessageContent,), {}) # type: ignore
|
|
MessageContent.THINKING = type("MessageContent.THINKING", (MessageContent.THINKING, MessageContent,), {}) # type: ignore
|
|
MessageContent.REDACTED_THINKING = type("MessageContent.REDACTED_THINKING", (MessageContent.REDACTED_THINKING, MessageContent,), {}) # type: ignore
|
|
|
|
|
|
|
|
|
|
class _UniffiConverterTypeMessageContent(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return MessageContent.TEXT(
|
|
_UniffiConverterTypeTextContent.read(buf),
|
|
)
|
|
if variant == 2:
|
|
return MessageContent.IMAGE(
|
|
_UniffiConverterTypeImageContent.read(buf),
|
|
)
|
|
if variant == 3:
|
|
return MessageContent.TOOL_REQ(
|
|
_UniffiConverterTypeToolRequest.read(buf),
|
|
)
|
|
if variant == 4:
|
|
return MessageContent.TOOL_RESP(
|
|
_UniffiConverterTypeToolResponse.read(buf),
|
|
)
|
|
if variant == 5:
|
|
return MessageContent.THINKING(
|
|
_UniffiConverterTypeThinkingContent.read(buf),
|
|
)
|
|
if variant == 6:
|
|
return MessageContent.REDACTED_THINKING(
|
|
_UniffiConverterTypeRedactedThinkingContent.read(buf),
|
|
)
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if value.is_TEXT():
|
|
_UniffiConverterTypeTextContent.check_lower(value._values[0])
|
|
return
|
|
if value.is_IMAGE():
|
|
_UniffiConverterTypeImageContent.check_lower(value._values[0])
|
|
return
|
|
if value.is_TOOL_REQ():
|
|
_UniffiConverterTypeToolRequest.check_lower(value._values[0])
|
|
return
|
|
if value.is_TOOL_RESP():
|
|
_UniffiConverterTypeToolResponse.check_lower(value._values[0])
|
|
return
|
|
if value.is_THINKING():
|
|
_UniffiConverterTypeThinkingContent.check_lower(value._values[0])
|
|
return
|
|
if value.is_REDACTED_THINKING():
|
|
_UniffiConverterTypeRedactedThinkingContent.check_lower(value._values[0])
|
|
return
|
|
raise ValueError(value)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if value.is_TEXT():
|
|
buf.write_i32(1)
|
|
_UniffiConverterTypeTextContent.write(value._values[0], buf)
|
|
if value.is_IMAGE():
|
|
buf.write_i32(2)
|
|
_UniffiConverterTypeImageContent.write(value._values[0], buf)
|
|
if value.is_TOOL_REQ():
|
|
buf.write_i32(3)
|
|
_UniffiConverterTypeToolRequest.write(value._values[0], buf)
|
|
if value.is_TOOL_RESP():
|
|
buf.write_i32(4)
|
|
_UniffiConverterTypeToolResponse.write(value._values[0], buf)
|
|
if value.is_THINKING():
|
|
buf.write_i32(5)
|
|
_UniffiConverterTypeThinkingContent.write(value._values[0], buf)
|
|
if value.is_REDACTED_THINKING():
|
|
buf.write_i32(6)
|
|
_UniffiConverterTypeRedactedThinkingContent.write(value._values[0], buf)
|
|
|
|
|
|
|
|
|
|
# ProviderError
|
|
# We want to define each variant as a nested class that's also a subclass,
|
|
# which is tricky in Python. To accomplish this we're going to create each
|
|
# class separately, then manually add the child classes to the base class's
|
|
# __dict__. All of this happens in dummy class to avoid polluting the module
|
|
# namespace.
|
|
class ProviderError(Exception):
|
|
pass
|
|
|
|
_UniffiTempProviderError = ProviderError
|
|
|
|
class ProviderError: # type: ignore
|
|
class Authentication(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.Authentication({})".format(str(self))
|
|
_UniffiTempProviderError.Authentication = Authentication # type: ignore
|
|
class ContextLengthExceeded(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.ContextLengthExceeded({})".format(str(self))
|
|
_UniffiTempProviderError.ContextLengthExceeded = ContextLengthExceeded # type: ignore
|
|
class RateLimitExceeded(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.RateLimitExceeded({})".format(str(self))
|
|
_UniffiTempProviderError.RateLimitExceeded = RateLimitExceeded # type: ignore
|
|
class ServerError(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.ServerError({})".format(str(self))
|
|
_UniffiTempProviderError.ServerError = ServerError # type: ignore
|
|
class RequestFailed(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.RequestFailed({})".format(str(self))
|
|
_UniffiTempProviderError.RequestFailed = RequestFailed # type: ignore
|
|
class ExecutionError(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.ExecutionError({})".format(str(self))
|
|
_UniffiTempProviderError.ExecutionError = ExecutionError # type: ignore
|
|
class UsageError(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.UsageError({})".format(str(self))
|
|
_UniffiTempProviderError.UsageError = UsageError # type: ignore
|
|
class ResponseParseError(_UniffiTempProviderError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ProviderError.ResponseParseError({})".format(str(self))
|
|
_UniffiTempProviderError.ResponseParseError = ResponseParseError # type: ignore
|
|
|
|
ProviderError = _UniffiTempProviderError # type: ignore
|
|
del _UniffiTempProviderError
|
|
|
|
|
|
class _UniffiConverterTypeProviderError(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return ProviderError.Authentication(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 2:
|
|
return ProviderError.ContextLengthExceeded(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 3:
|
|
return ProviderError.RateLimitExceeded(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 4:
|
|
return ProviderError.ServerError(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 5:
|
|
return ProviderError.RequestFailed(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 6:
|
|
return ProviderError.ExecutionError(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 7:
|
|
return ProviderError.UsageError(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 8:
|
|
return ProviderError.ResponseParseError(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if isinstance(value, ProviderError.Authentication):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.ContextLengthExceeded):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.RateLimitExceeded):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.ServerError):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.RequestFailed):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.ExecutionError):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.UsageError):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ProviderError.ResponseParseError):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if isinstance(value, ProviderError.Authentication):
|
|
buf.write_i32(1)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.ContextLengthExceeded):
|
|
buf.write_i32(2)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.RateLimitExceeded):
|
|
buf.write_i32(3)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.ServerError):
|
|
buf.write_i32(4)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.RequestFailed):
|
|
buf.write_i32(5)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.ExecutionError):
|
|
buf.write_i32(6)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.UsageError):
|
|
buf.write_i32(7)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ProviderError.ResponseParseError):
|
|
buf.write_i32(8)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
|
|
|
|
|
|
|
|
|
|
class Role(enum.Enum):
|
|
USER = 0
|
|
|
|
ASSISTANT = 1
|
|
|
|
|
|
|
|
class _UniffiConverterTypeRole(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return Role.USER
|
|
if variant == 2:
|
|
return Role.ASSISTANT
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if value == Role.USER:
|
|
return
|
|
if value == Role.ASSISTANT:
|
|
return
|
|
raise ValueError(value)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if value == Role.USER:
|
|
buf.write_i32(1)
|
|
if value == Role.ASSISTANT:
|
|
buf.write_i32(2)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class ToolApprovalMode(enum.Enum):
|
|
AUTO = 0
|
|
|
|
MANUAL = 1
|
|
|
|
SMART = 2
|
|
|
|
|
|
|
|
class _UniffiConverterTypeToolApprovalMode(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return ToolApprovalMode.AUTO
|
|
if variant == 2:
|
|
return ToolApprovalMode.MANUAL
|
|
if variant == 3:
|
|
return ToolApprovalMode.SMART
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if value == ToolApprovalMode.AUTO:
|
|
return
|
|
if value == ToolApprovalMode.MANUAL:
|
|
return
|
|
if value == ToolApprovalMode.SMART:
|
|
return
|
|
raise ValueError(value)
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if value == ToolApprovalMode.AUTO:
|
|
buf.write_i32(1)
|
|
if value == ToolApprovalMode.MANUAL:
|
|
buf.write_i32(2)
|
|
if value == ToolApprovalMode.SMART:
|
|
buf.write_i32(3)
|
|
|
|
|
|
|
|
|
|
# ToolError
|
|
# We want to define each variant as a nested class that's also a subclass,
|
|
# which is tricky in Python. To accomplish this we're going to create each
|
|
# class separately, then manually add the child classes to the base class's
|
|
# __dict__. All of this happens in dummy class to avoid polluting the module
|
|
# namespace.
|
|
class ToolError(Exception):
|
|
pass
|
|
|
|
_UniffiTempToolError = ToolError
|
|
|
|
class ToolError: # type: ignore
|
|
class InvalidParameters(_UniffiTempToolError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ToolError.InvalidParameters({})".format(str(self))
|
|
_UniffiTempToolError.InvalidParameters = InvalidParameters # type: ignore
|
|
class ExecutionError(_UniffiTempToolError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ToolError.ExecutionError({})".format(str(self))
|
|
_UniffiTempToolError.ExecutionError = ExecutionError # type: ignore
|
|
class SchemaError(_UniffiTempToolError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ToolError.SchemaError({})".format(str(self))
|
|
_UniffiTempToolError.SchemaError = SchemaError # type: ignore
|
|
class NotFound(_UniffiTempToolError):
|
|
def __init__(self, *values):
|
|
if len(values) != 1:
|
|
raise TypeError(f"Expected 1 arguments, found {len(values)}")
|
|
if not isinstance(values[0], str):
|
|
raise TypeError(f"unexpected type for tuple element 0 - expected 'str', got '{type(values[0])}'")
|
|
super().__init__(", ".join(map(repr, values)))
|
|
self._values = values
|
|
|
|
def __getitem__(self, index):
|
|
return self._values[index]
|
|
|
|
def __repr__(self):
|
|
return "ToolError.NotFound({})".format(str(self))
|
|
_UniffiTempToolError.NotFound = NotFound # type: ignore
|
|
|
|
ToolError = _UniffiTempToolError # type: ignore
|
|
del _UniffiTempToolError
|
|
|
|
|
|
class _UniffiConverterTypeToolError(_UniffiConverterRustBuffer):
|
|
@staticmethod
|
|
def read(buf):
|
|
variant = buf.read_i32()
|
|
if variant == 1:
|
|
return ToolError.InvalidParameters(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 2:
|
|
return ToolError.ExecutionError(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 3:
|
|
return ToolError.SchemaError(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
if variant == 4:
|
|
return ToolError.NotFound(
|
|
_UniffiConverterString.read(buf),
|
|
)
|
|
raise InternalError("Raw enum value doesn't match any cases")
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
if isinstance(value, ToolError.InvalidParameters):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ToolError.ExecutionError):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ToolError.SchemaError):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
if isinstance(value, ToolError.NotFound):
|
|
_UniffiConverterString.check_lower(value._values[0])
|
|
return
|
|
|
|
@staticmethod
|
|
def write(value, buf):
|
|
if isinstance(value, ToolError.InvalidParameters):
|
|
buf.write_i32(1)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ToolError.ExecutionError):
|
|
buf.write_i32(2)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ToolError.SchemaError):
|
|
buf.write_i32(3)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
if isinstance(value, ToolError.NotFound):
|
|
buf.write_i32(4)
|
|
_UniffiConverterString.write(value._values[0], buf)
|
|
|
|
|
|
|
|
class _UniffiConverterOptionalUInt32(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
if value is not None:
|
|
_UniffiConverterUInt32.check_lower(value)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
if value is None:
|
|
buf.write_u8(0)
|
|
return
|
|
|
|
buf.write_u8(1)
|
|
_UniffiConverterUInt32.write(value, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
flag = buf.read_u8()
|
|
if flag == 0:
|
|
return None
|
|
elif flag == 1:
|
|
return _UniffiConverterUInt32.read(buf)
|
|
else:
|
|
raise InternalError("Unexpected flag byte for optional type")
|
|
|
|
|
|
|
|
class _UniffiConverterOptionalInt32(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
if value is not None:
|
|
_UniffiConverterInt32.check_lower(value)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
if value is None:
|
|
buf.write_u8(0)
|
|
return
|
|
|
|
buf.write_u8(1)
|
|
_UniffiConverterInt32.write(value, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
flag = buf.read_u8()
|
|
if flag == 0:
|
|
return None
|
|
elif flag == 1:
|
|
return _UniffiConverterInt32.read(buf)
|
|
else:
|
|
raise InternalError("Unexpected flag byte for optional type")
|
|
|
|
|
|
|
|
class _UniffiConverterOptionalFloat(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
if value is not None:
|
|
_UniffiConverterFloat.check_lower(value)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
if value is None:
|
|
buf.write_u8(0)
|
|
return
|
|
|
|
buf.write_u8(1)
|
|
_UniffiConverterFloat.write(value, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
flag = buf.read_u8()
|
|
if flag == 0:
|
|
return None
|
|
elif flag == 1:
|
|
return _UniffiConverterFloat.read(buf)
|
|
else:
|
|
raise InternalError("Unexpected flag byte for optional type")
|
|
|
|
|
|
|
|
class _UniffiConverterOptionalDouble(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
if value is not None:
|
|
_UniffiConverterDouble.check_lower(value)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
if value is None:
|
|
buf.write_u8(0)
|
|
return
|
|
|
|
buf.write_u8(1)
|
|
_UniffiConverterDouble.write(value, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
flag = buf.read_u8()
|
|
if flag == 0:
|
|
return None
|
|
elif flag == 1:
|
|
return _UniffiConverterDouble.read(buf)
|
|
else:
|
|
raise InternalError("Unexpected flag byte for optional type")
|
|
|
|
|
|
|
|
class _UniffiConverterOptionalString(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
if value is not None:
|
|
_UniffiConverterString.check_lower(value)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
if value is None:
|
|
buf.write_u8(0)
|
|
return
|
|
|
|
buf.write_u8(1)
|
|
_UniffiConverterString.write(value, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
flag = buf.read_u8()
|
|
if flag == 0:
|
|
return None
|
|
elif flag == 1:
|
|
return _UniffiConverterString.read(buf)
|
|
else:
|
|
raise InternalError("Unexpected flag byte for optional type")
|
|
|
|
|
|
|
|
class _UniffiConverterSequenceTypeExtensionConfig(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
for item in value:
|
|
_UniffiConverterTypeExtensionConfig.check_lower(item)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
items = len(value)
|
|
buf.write_i32(items)
|
|
for item in value:
|
|
_UniffiConverterTypeExtensionConfig.write(item, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
count = buf.read_i32()
|
|
if count < 0:
|
|
raise InternalError("Unexpected negative sequence length")
|
|
|
|
return [
|
|
_UniffiConverterTypeExtensionConfig.read(buf) for i in range(count)
|
|
]
|
|
|
|
|
|
|
|
class _UniffiConverterSequenceTypeMessage(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
for item in value:
|
|
_UniffiConverterTypeMessage.check_lower(item)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
items = len(value)
|
|
buf.write_i32(items)
|
|
for item in value:
|
|
_UniffiConverterTypeMessage.write(item, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
count = buf.read_i32()
|
|
if count < 0:
|
|
raise InternalError("Unexpected negative sequence length")
|
|
|
|
return [
|
|
_UniffiConverterTypeMessage.read(buf) for i in range(count)
|
|
]
|
|
|
|
|
|
|
|
class _UniffiConverterSequenceTypeMessageContent(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
for item in value:
|
|
_UniffiConverterTypeMessageContent.check_lower(item)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
items = len(value)
|
|
buf.write_i32(items)
|
|
for item in value:
|
|
_UniffiConverterTypeMessageContent.write(item, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
count = buf.read_i32()
|
|
if count < 0:
|
|
raise InternalError("Unexpected negative sequence length")
|
|
|
|
return [
|
|
_UniffiConverterTypeMessageContent.read(buf) for i in range(count)
|
|
]
|
|
|
|
|
|
|
|
class _UniffiConverterSequenceTypeToolConfig(_UniffiConverterRustBuffer):
|
|
@classmethod
|
|
def check_lower(cls, value):
|
|
for item in value:
|
|
_UniffiConverterTypeToolConfig.check_lower(item)
|
|
|
|
@classmethod
|
|
def write(cls, value, buf):
|
|
items = len(value)
|
|
buf.write_i32(items)
|
|
for item in value:
|
|
_UniffiConverterTypeToolConfig.write(item, buf)
|
|
|
|
@classmethod
|
|
def read(cls, buf):
|
|
count = buf.read_i32()
|
|
if count < 0:
|
|
raise InternalError("Unexpected negative sequence length")
|
|
|
|
return [
|
|
_UniffiConverterTypeToolConfig.read(buf) for i in range(count)
|
|
]
|
|
|
|
|
|
class _UniffiConverterTypeCompletionRequest:
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value, buf)
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return _UniffiConverterString.read(buf)
|
|
|
|
@staticmethod
|
|
def lift(value):
|
|
return _UniffiConverterString.lift(value)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
return _UniffiConverterString.check_lower(value)
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
return _UniffiConverterString.lower(value)
|
|
|
|
|
|
class _UniffiConverterTypeContents:
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterSequenceTypeMessageContent.write(value, buf)
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return _UniffiConverterSequenceTypeMessageContent.read(buf)
|
|
|
|
@staticmethod
|
|
def lift(value):
|
|
return _UniffiConverterSequenceTypeMessageContent.lift(value)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
return _UniffiConverterSequenceTypeMessageContent.check_lower(value)
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
return _UniffiConverterSequenceTypeMessageContent.lower(value)
|
|
|
|
|
|
class _UniffiConverterTypeJsonValueFfi:
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value, buf)
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return _UniffiConverterString.read(buf)
|
|
|
|
@staticmethod
|
|
def lift(value):
|
|
return _UniffiConverterString.lift(value)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
return _UniffiConverterString.check_lower(value)
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
return _UniffiConverterString.lower(value)
|
|
|
|
|
|
class _UniffiConverterTypeToolConfig:
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value, buf)
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return _UniffiConverterString.read(buf)
|
|
|
|
@staticmethod
|
|
def lift(value):
|
|
return _UniffiConverterString.lift(value)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
return _UniffiConverterString.check_lower(value)
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
return _UniffiConverterString.lower(value)
|
|
|
|
|
|
class _UniffiConverterTypeToolRequestToolCall:
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value, buf)
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return _UniffiConverterString.read(buf)
|
|
|
|
@staticmethod
|
|
def lift(value):
|
|
return _UniffiConverterString.lift(value)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
return _UniffiConverterString.check_lower(value)
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
return _UniffiConverterString.lower(value)
|
|
|
|
|
|
class _UniffiConverterTypeToolResponseToolResult:
|
|
@staticmethod
|
|
def write(value, buf):
|
|
_UniffiConverterString.write(value, buf)
|
|
|
|
@staticmethod
|
|
def read(buf):
|
|
return _UniffiConverterString.read(buf)
|
|
|
|
@staticmethod
|
|
def lift(value):
|
|
return _UniffiConverterString.lift(value)
|
|
|
|
@staticmethod
|
|
def check_lower(value):
|
|
return _UniffiConverterString.check_lower(value)
|
|
|
|
@staticmethod
|
|
def lower(value):
|
|
return _UniffiConverterString.lower(value)
|
|
|
|
# objects.
|
|
CompletionRequest = str
|
|
Contents = typing.List[MessageContent]
|
|
JsonValueFfi = str
|
|
ToolConfig = str
|
|
ToolRequestToolCall = str
|
|
ToolResponseToolResult = str
|
|
|
|
# Async support# RustFuturePoll values
|
|
_UNIFFI_RUST_FUTURE_POLL_READY = 0
|
|
_UNIFFI_RUST_FUTURE_POLL_MAYBE_READY = 1
|
|
|
|
# Stores futures for _uniffi_continuation_callback
|
|
_UniffiContinuationHandleMap = _UniffiHandleMap()
|
|
|
|
_UNIFFI_GLOBAL_EVENT_LOOP = None
|
|
|
|
"""
|
|
Set the event loop to use for async functions
|
|
|
|
This is needed if some async functions run outside of the eventloop, for example:
|
|
- A non-eventloop thread is spawned, maybe from `EventLoop.run_in_executor` or maybe from the
|
|
Rust code spawning its own thread.
|
|
- The Rust code calls an async callback method from a sync callback function, using something
|
|
like `pollster` to block on the async call.
|
|
|
|
In this case, we need an event loop to run the Python async function, but there's no eventloop set
|
|
for the thread. Use `uniffi_set_event_loop` to force an eventloop to be used in this case.
|
|
"""
|
|
def uniffi_set_event_loop(eventloop: asyncio.BaseEventLoop):
|
|
global _UNIFFI_GLOBAL_EVENT_LOOP
|
|
_UNIFFI_GLOBAL_EVENT_LOOP = eventloop
|
|
|
|
def _uniffi_get_event_loop():
|
|
if _UNIFFI_GLOBAL_EVENT_LOOP is not None:
|
|
return _UNIFFI_GLOBAL_EVENT_LOOP
|
|
else:
|
|
return asyncio.get_running_loop()
|
|
|
|
# Continuation callback for async functions
|
|
# lift the return value or error and resolve the future, causing the async function to resume.
|
|
@_UNIFFI_RUST_FUTURE_CONTINUATION_CALLBACK
|
|
def _uniffi_continuation_callback(future_ptr, poll_code):
|
|
(eventloop, future) = _UniffiContinuationHandleMap.remove(future_ptr)
|
|
eventloop.call_soon_threadsafe(_uniffi_set_future_result, future, poll_code)
|
|
|
|
def _uniffi_set_future_result(future, poll_code):
|
|
if not future.cancelled():
|
|
future.set_result(poll_code)
|
|
|
|
async def _uniffi_rust_call_async(rust_future, ffi_poll, ffi_complete, ffi_free, lift_func, error_ffi_converter):
|
|
try:
|
|
eventloop = _uniffi_get_event_loop()
|
|
|
|
# Loop and poll until we see a _UNIFFI_RUST_FUTURE_POLL_READY value
|
|
while True:
|
|
future = eventloop.create_future()
|
|
ffi_poll(
|
|
rust_future,
|
|
_uniffi_continuation_callback,
|
|
_UniffiContinuationHandleMap.insert((eventloop, future)),
|
|
)
|
|
poll_code = await future
|
|
if poll_code == _UNIFFI_RUST_FUTURE_POLL_READY:
|
|
break
|
|
|
|
return lift_func(
|
|
_uniffi_rust_call_with_error(error_ffi_converter, ffi_complete, rust_future)
|
|
)
|
|
finally:
|
|
ffi_free(rust_future)
|
|
async def completion(req: "CompletionRequest") -> "CompletionResponse":
|
|
|
|
"""
|
|
Public API for the Goose LLM completion function
|
|
"""
|
|
|
|
_UniffiConverterTypeCompletionRequest.check_lower(req)
|
|
|
|
return await _uniffi_rust_call_async(
|
|
_UniffiLib.uniffi_goose_llm_fn_func_completion(
|
|
_UniffiConverterTypeCompletionRequest.lower(req)),
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_rust_buffer,
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_rust_buffer,
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_rust_buffer,
|
|
# lift function
|
|
_UniffiConverterTypeCompletionResponse.lift,
|
|
|
|
# Error FFI converter
|
|
_UniffiConverterTypeCompletionError,
|
|
|
|
)
|
|
|
|
def create_completion_request(provider_name: "str",provider_config: "JsonValueFfi",model_config: "ModelConfig",system_preamble: "str",messages: "typing.List[Message]",extensions: "typing.List[ExtensionConfig]") -> "CompletionRequest":
|
|
_UniffiConverterString.check_lower(provider_name)
|
|
|
|
_UniffiConverterTypeJsonValueFfi.check_lower(provider_config)
|
|
|
|
_UniffiConverterTypeModelConfig.check_lower(model_config)
|
|
|
|
_UniffiConverterString.check_lower(system_preamble)
|
|
|
|
_UniffiConverterSequenceTypeMessage.check_lower(messages)
|
|
|
|
_UniffiConverterSequenceTypeExtensionConfig.check_lower(extensions)
|
|
|
|
return _UniffiConverterTypeCompletionRequest.lift(_uniffi_rust_call(_UniffiLib.uniffi_goose_llm_fn_func_create_completion_request,
|
|
_UniffiConverterString.lower(provider_name),
|
|
_UniffiConverterTypeJsonValueFfi.lower(provider_config),
|
|
_UniffiConverterTypeModelConfig.lower(model_config),
|
|
_UniffiConverterString.lower(system_preamble),
|
|
_UniffiConverterSequenceTypeMessage.lower(messages),
|
|
_UniffiConverterSequenceTypeExtensionConfig.lower(extensions)))
|
|
|
|
|
|
def create_tool_config(name: "str",description: "str",input_schema: "JsonValueFfi",approval_mode: "ToolApprovalMode") -> "ToolConfig":
|
|
_UniffiConverterString.check_lower(name)
|
|
|
|
_UniffiConverterString.check_lower(description)
|
|
|
|
_UniffiConverterTypeJsonValueFfi.check_lower(input_schema)
|
|
|
|
_UniffiConverterTypeToolApprovalMode.check_lower(approval_mode)
|
|
|
|
return _UniffiConverterTypeToolConfig.lift(_uniffi_rust_call(_UniffiLib.uniffi_goose_llm_fn_func_create_tool_config,
|
|
_UniffiConverterString.lower(name),
|
|
_UniffiConverterString.lower(description),
|
|
_UniffiConverterTypeJsonValueFfi.lower(input_schema),
|
|
_UniffiConverterTypeToolApprovalMode.lower(approval_mode)))
|
|
|
|
async def generate_session_name(provider_name: "str",provider_config: "JsonValueFfi",messages: "typing.List[Message]") -> "str":
|
|
|
|
"""
|
|
Generates a short (≤4 words) session name
|
|
"""
|
|
|
|
_UniffiConverterString.check_lower(provider_name)
|
|
|
|
_UniffiConverterTypeJsonValueFfi.check_lower(provider_config)
|
|
|
|
_UniffiConverterSequenceTypeMessage.check_lower(messages)
|
|
|
|
return await _uniffi_rust_call_async(
|
|
_UniffiLib.uniffi_goose_llm_fn_func_generate_session_name(
|
|
_UniffiConverterString.lower(provider_name),
|
|
_UniffiConverterTypeJsonValueFfi.lower(provider_config),
|
|
_UniffiConverterSequenceTypeMessage.lower(messages)),
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_rust_buffer,
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_rust_buffer,
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_rust_buffer,
|
|
# lift function
|
|
_UniffiConverterString.lift,
|
|
|
|
# Error FFI converter
|
|
_UniffiConverterTypeProviderError,
|
|
|
|
)
|
|
async def generate_tooltip(provider_name: "str",provider_config: "JsonValueFfi",messages: "typing.List[Message]") -> "str":
|
|
|
|
"""
|
|
Generates a tooltip summarizing the last two messages in the session,
|
|
including any tool calls or results.
|
|
"""
|
|
|
|
_UniffiConverterString.check_lower(provider_name)
|
|
|
|
_UniffiConverterTypeJsonValueFfi.check_lower(provider_config)
|
|
|
|
_UniffiConverterSequenceTypeMessage.check_lower(messages)
|
|
|
|
return await _uniffi_rust_call_async(
|
|
_UniffiLib.uniffi_goose_llm_fn_func_generate_tooltip(
|
|
_UniffiConverterString.lower(provider_name),
|
|
_UniffiConverterTypeJsonValueFfi.lower(provider_config),
|
|
_UniffiConverterSequenceTypeMessage.lower(messages)),
|
|
_UniffiLib.ffi_goose_llm_rust_future_poll_rust_buffer,
|
|
_UniffiLib.ffi_goose_llm_rust_future_complete_rust_buffer,
|
|
_UniffiLib.ffi_goose_llm_rust_future_free_rust_buffer,
|
|
# lift function
|
|
_UniffiConverterString.lift,
|
|
|
|
# Error FFI converter
|
|
_UniffiConverterTypeProviderError,
|
|
|
|
)
|
|
|
|
def print_messages(messages: "typing.List[Message]") -> None:
|
|
_UniffiConverterSequenceTypeMessage.check_lower(messages)
|
|
|
|
_uniffi_rust_call(_UniffiLib.uniffi_goose_llm_fn_func_print_messages,
|
|
_UniffiConverterSequenceTypeMessage.lower(messages))
|
|
|
|
|
|
__all__ = [
|
|
"InternalError",
|
|
"CompletionError",
|
|
"Content",
|
|
"MessageContent",
|
|
"ProviderError",
|
|
"Role",
|
|
"ToolApprovalMode",
|
|
"ToolError",
|
|
"CompletionResponse",
|
|
"ExtensionConfig",
|
|
"ImageContent",
|
|
"Message",
|
|
"ModelConfig",
|
|
"ProviderCompleteResponse",
|
|
"RedactedThinkingContent",
|
|
"RuntimeMetrics",
|
|
"TextContent",
|
|
"ThinkingContent",
|
|
"ToolRequest",
|
|
"ToolResponse",
|
|
"Usage",
|
|
"completion",
|
|
"create_completion_request",
|
|
"create_tool_config",
|
|
"generate_session_name",
|
|
"generate_tooltip",
|
|
"print_messages",
|
|
]
|
|
|