@dbx-tools/model-rs 0.6.221

package/src/_bindings.ts

@@ -0,0 +1,284 @@
+// GENERATED by UniFFI binding generation - DO NOT EDIT.
+// Regenerated from the dbx-tools-model Rust exports.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+/* eslint-disable */
+// @ts-nocheck
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+import nativeModule from "./_bindings-ffi.ts";
+import { type UniffiRustFutureContinuationCallback, type UniffiForeignFutureDroppedCallback, type UniffiForeignFutureDroppedCallbackStruct,
+} from "./_bindings-ffi.ts";
+import { type UniffiByteArray, AbstractFfiConverterByteArray, Cursor, FfiConverterArray, FfiConverterBool, FfiConverterOptional, FfiConverterUInt8, RustBuffer, UniffiEnum, UniffiInternalError, UniffiRustCaller, uniffiCreateFfiConverterString,
+} from "@ubjs/core";
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+
+// Public interface members begin here.
+
+/**
+ * Return the Chat Completions effort required when function tools are present.
+ */
+export function chatToolReasoningEffort(name: string): ReasoningEffort | undefined {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_model_fn_func_chat_tool_reasoning_effort(
+        FfiConverterString.lower(name, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterOptionalTypeReasoningEffort.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Return whether a model requires Databricks' native Responses endpoint.
+ */
+export function isResponsesOnly(value: string): boolean {
+    return FfiConverterBool.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_model_fn_func_is_responses_only(
+        FfiConverterString.lower(value, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+/**
+ * Return the Databricks inference protocol required by a model.
+ */
+export function modelServingApi(value: string): ModelServingApi {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_model_fn_func_model_serving_api(
+        FfiConverterString.lower(value, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterTypeModelServingApi.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Infer the accepted reasoning efforts from a model or service name.
+ */
+export function reasoningEffortsByFamily(name: string): Array<ReasoningEffort> {
+    const __rb: Uint8Array = uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_model_fn_func_reasoning_efforts_by_family(
+        FfiConverterString.lower(name, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    );
+    try {
+        return FfiConverterSequenceTypeReasoningEffort.lift(__rb);
+    } finally {
+        nativeModule().rustbuffer_free(__rb);
+    }
+    }
+
+/**
+ * Infer whether a model family supports a complete tool-calling round trip.
+ */
+export function supportsToolsByFamily(name: string): boolean {
+    return FfiConverterBool.lift(uniffiCaller.rustCall(
+            /*caller:*/ (callStatus) => {
+                return nativeModule().uniffi_dbx_tools_model_fn_func_supports_tools_by_family(
+        FfiConverterString.lower(name, nativeModule().rustbuffer_alloc),
+                callStatus);
+            },
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+    ));
+    }
+
+/**
+ * Databricks inference protocol selected for a model.
+ */
+export enum ModelServingApi {
+    /**
+     * OpenAI-compatible Chat Completions.
+     */
+    Chat,
+    /**
+     * Native OpenAI Responses.
+     */
+    Responses
+}
+
+const FfiConverterTypeModelServingApi = (() => {
+    type TypeName = ModelServingApi;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return ModelServingApi.Chat;
+                case 2: return ModelServingApi.Responses;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case ModelServingApi.Chat: return c.writeI32(1);
+                case ModelServingApi.Responses: return c.writeI32(2);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+/**
+ * Reasoning effort accepted by a model endpoint.
+ */
+export enum ReasoningEffort {
+    /**
+     * Disable explicit reasoning.
+     */
+    None,
+    /**
+     * Use the smallest available reasoning budget.
+     */
+    Minimal,
+    /**
+     * Use a low reasoning budget.
+     */
+    Low,
+    /**
+     * Use a medium reasoning budget.
+     */
+    Medium,
+    /**
+     * Use a high reasoning budget.
+     */
+    High,
+    /**
+     * Use an extra-high reasoning budget.
+     */
+    Xhigh,
+    /**
+     * Use the largest available reasoning budget.
+     */
+    Max
+}
+
+const FfiConverterTypeReasoningEffort = (() => {
+    type TypeName = ReasoningEffort;
+    class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+        readFromCursor(c: Cursor): TypeName {
+            switch (c.readI32()) {
+                case 1: return ReasoningEffort.None;
+                case 2: return ReasoningEffort.Minimal;
+                case 3: return ReasoningEffort.Low;
+                case 4: return ReasoningEffort.Medium;
+                case 5: return ReasoningEffort.High;
+                case 6: return ReasoningEffort.Xhigh;
+                case 7: return ReasoningEffort.Max;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        writeIntoCursor(value: TypeName, c: Cursor): void {
+            switch (value) {
+                case ReasoningEffort.None: return c.writeI32(1);
+                case ReasoningEffort.Minimal: return c.writeI32(2);
+                case ReasoningEffort.Low: return c.writeI32(3);
+                case ReasoningEffort.Medium: return c.writeI32(4);
+                case ReasoningEffort.High: return c.writeI32(5);
+                case ReasoningEffort.Xhigh: return c.writeI32(6);
+                case ReasoningEffort.Max: return c.writeI32(7);
+            }
+        }
+        allocationSize(value: TypeName): number {
+            return 4;
+        }
+    }
+    return new FFIConverter();
+})();
+
+const stringConverter = (() => {
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    return {
+        stringToBytes: (s: string) => encoder.encode(s),
+        bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+        stringByteLength: (s: string) => encoder.encode(s).byteLength,
+        writeStringIntoBuffer: (s: string, buf: any, offset: number): number => {
+            const view = new Uint8Array(
+                buf.arrayBuffer,
+                offset,
+                buf.arrayBuffer.byteLength - offset,
+            );
+            return encoder.encodeInto(s, view).written;
+        },
+        readStringFromBuffer: (buf: any, offset: number, length: number): string =>
+            decoder.decode(new Uint8Array(buf.arrayBuffer, offset, length)),
+    };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+// FfiConverter for ReasoningEffort | undefined
+const FfiConverterOptionalTypeReasoningEffort = new FfiConverterOptional(FfiConverterTypeReasoningEffort);
+
+// FfiConverter for Array<ReasoningEffort>
+const FfiConverterSequenceTypeReasoningEffort = new FfiConverterArray(FfiConverterTypeReasoningEffort);
+
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+    // Get the bindings contract version from our ComponentInterface
+    const bindingsContractVersion = 30;
+    // Get the scaffolding contract version by calling the into the dylib
+    const scaffoldingContractVersion = nativeModule().ffi_dbx_tools_model_uniffi_contract_version();
+    if (bindingsContractVersion !== scaffoldingContractVersion) {
+        throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+    }
+    if (nativeModule().uniffi_dbx_tools_model_checksum_func_chat_tool_reasoning_effort() !== 31707) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_model_checksum_func_chat_tool_reasoning_effort");
+    }
+    if (nativeModule().uniffi_dbx_tools_model_checksum_func_is_responses_only() !== 5794) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_model_checksum_func_is_responses_only");
+    }
+    if (nativeModule().uniffi_dbx_tools_model_checksum_func_model_serving_api() !== 54338) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_model_checksum_func_model_serving_api");
+    }
+    if (nativeModule().uniffi_dbx_tools_model_checksum_func_reasoning_efforts_by_family() !== 49390) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_model_checksum_func_reasoning_efforts_by_family");
+    }
+    if (nativeModule().uniffi_dbx_tools_model_checksum_func_supports_tools_by_family() !== 34147) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_dbx_tools_model_checksum_func_supports_tools_by_family");
+    }
+
+    }
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeModelServingApi,
+    FfiConverterTypeReasoningEffort,
+  }
+});

package/src/bindings.ts

@@ -0,0 +1,11 @@
+// GENERATED by UniFFI binding generation - DO NOT EDIT.
+// Regenerated from the dbx-tools-model Rust exports.
+// Hand edits are overwritten on the next watch; this file is read-only.
+
+/* eslint-disable */
+// @ts-nocheck
+export * from './_bindings.ts';
+import uniffiModule from './_bindings.ts';
+uniffiModule.initialize();
+export { uniffiModule };
+export async function uniffiInitAsync() {}