@qvac/sdk 0.3.0 → 0.4.1

package/dist/schemas/load-model.js

@@ -3,49 +3,176 @@ import { llmConfigSchema, embedConfigSchema } from "./llamacpp-config.js";
 import { whisperConfigSchema } from "./whispercpp-config.js";
 import { delegateSchema } from "./delegate.js";
 import { nmtConfigSchema } from "./translation-config.js";
-export const loadModelOptionsSchema = z
-    .union([
+import { ttsConfigSchema } from "./text-to-speech.js";
+import { modelSrcInputSchema, modelInputToSrcSchema, modelInputToNameSchema, } from "./model-src-utils.js";
+const loadModelOptionsBaseSchema = z.union([
     z.object({
-        modelSrc: z.string(),
+        modelSrc: modelSrcInputSchema,
         modelType: z.literal("llm"),
         modelConfig: llmConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
-        projectionModelSrc: z.string().optional(),
+        projectionModelSrc: modelSrcInputSchema.optional(),
         delegate: delegateSchema,
         toolFormat: z.enum(["json", "xml"]).default("json"),
     }),
     z.object({
-        modelSrc: z.string(),
+        modelSrc: modelSrcInputSchema,
         modelType: z.literal("whisper"),
         modelConfig: whisperConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
-        vadModelSrc: z.string().optional(),
+        vadModelSrc: modelSrcInputSchema.optional(),
         delegate: delegateSchema,
     }),
     z.object({
-        modelSrc: z.string(),
+        modelSrc: modelSrcInputSchema,
         modelType: z.literal("embeddings"),
         modelConfig: embedConfigSchema.partial().strict().optional(),
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
     z.object({
-        modelSrc: z.string(),
+        modelSrc: modelSrcInputSchema,
         modelType: z.literal("nmt"),
         modelConfig: nmtConfigSchema,
         seed: z.boolean().optional(),
         delegate: delegateSchema,
     }),
-])
-    .transform((data) => ({
+    z.object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.literal("tts"),
+        modelConfig: ttsConfigSchema,
+        configSrc: modelSrcInputSchema,
+        eSpeakDataPath: z.string(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
+]);
+export const loadModelOptionsSchema = loadModelOptionsBaseSchema.transform((data) => ({
     ...data,
     seed: data.seed ?? false,
 }));
+export const loadModelOptionsToRequestSchema = z.union([
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.literal("llm"),
+        modelConfig: llmConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        projectionModelSrc: modelSrcInputSchema.optional(),
+        delegate: delegateSchema,
+        toolFormat: z.enum(["json", "xml"]).default("json"),
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: "llm",
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: (data.modelConfig ?? {}),
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+        projectionModelSrc: data.projectionModelSrc
+            ? modelInputToSrcSchema.parse(data.projectionModelSrc)
+            : undefined,
+    })),
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.literal("whisper"),
+        modelConfig: whisperConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        vadModelSrc: modelSrcInputSchema.optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: "whisper",
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: (data.modelConfig ?? {}),
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+        vadModelSrc: data.vadModelSrc
+            ? modelInputToSrcSchema.parse(data.vadModelSrc)
+            : undefined,
+    })),
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.literal("embeddings"),
+        modelConfig: embedConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: "embeddings",
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: (data.modelConfig ?? {}),
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+    })),
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.literal("nmt"),
+        modelConfig: nmtConfigSchema,
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: "nmt",
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: data.modelConfig,
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+    })),
+    z
+        .object({
+        modelSrc: modelSrcInputSchema,
+        modelType: z.literal("tts"),
+        modelConfig: ttsConfigSchema,
+        configSrc: modelSrcInputSchema,
+        eSpeakDataPath: z.string(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+        onProgress: z.unknown().optional(),
+        withProgress: z.boolean().optional(),
+    })
+        .transform((data) => ({
+        type: "loadModel",
+        modelType: "tts",
+        modelSrc: modelInputToSrcSchema.parse(data.modelSrc),
+        modelName: modelInputToNameSchema.parse(data.modelSrc),
+        modelConfig: data.modelConfig,
+        seed: data.seed ?? false,
+        withProgress: data.withProgress ?? !!data.onProgress,
+        delegate: data.delegate,
+        configSrc: modelInputToSrcSchema.parse(data.configSrc),
+        eSpeakDataPath: data.eSpeakDataPath,
+    })),
+]);
 const commonModelConfigSchema = z.object({
     type: z.literal("loadModel"),
     modelSrc: z.string(),
+    modelName: z.string().optional(),
     projectionModelSrc: z.string().optional(),
     vadModelSrc: z.string().optional(),
+    configSrc: z.string().optional(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
     delegate: delegateSchema,
@@ -67,6 +194,12 @@ export const loadNmtModelRequestSchema = commonModelConfigSchema.extend({
     modelType: z.literal("nmt"),
     modelConfig: nmtConfigSchema,
 });
+export const loadTtsModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("tts"),
+    modelConfig: ttsConfigSchema,
+    configSrc: z.string(),
+    eSpeakDataPath: z.string(),
+});
 // Union of all load model request types
 export const loadModelRequestSchema = z
     .discriminatedUnion("modelType", [
@@ -74,6 +207,7 @@ export const loadModelRequestSchema = z
     loadWhisperModelRequestSchema,
     loadEmbeddingsModelRequestSchema,
     loadNmtModelRequestSchema,
+    loadTtsModelRequestSchema,
 ])
     .transform((data) => ({
     ...data,
@@ -91,6 +225,16 @@ export const modelProgressUpdateSchema = z.object({
     total: z.number(),
     percentage: z.number(),
     downloadKey: z.string(),
+    shardInfo: z
+        .object({
+        currentShard: z.number(),
+        totalShards: z.number(),
+        shardName: z.string(),
+        overallDownloaded: z.number(),
+        overallTotal: z.number(),
+        overallPercentage: z.number(),
+    })
+        .optional(),
 });
 export const hyperdriveUrlSchema = z
     .string()
@@ -105,4 +249,7 @@ export const loadModelServerParamsSchema = z.object({
     options: loadModelOptionsSchema,
     projectionModelPath: z.string().optional(),
     vadModelPath: z.string().optional(),
+    ttsConfigModelPath: z.string().optional(),
+    eSpeakDataPath: z.string().optional(),
+    modelName: z.string().optional(),
 });

package/dist/schemas/model-src-utils.d.ts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export declare const modelDescriptorSchema: z.ZodObject<{
+    src: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodString>;
+    hyperdriveKey: z.ZodOptional<z.ZodString>;
+    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    expectedSize: z.ZodOptional<z.ZodNumber>;
+    sha256Checksum: z.ZodOptional<z.ZodString>;
+    addon: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        vad: "vad";
+        tts: "tts";
+    }>>;
+}, z.core.$strip>;
+export declare const modelSrcInputSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    src: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodString>;
+    hyperdriveKey: z.ZodOptional<z.ZodString>;
+    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    expectedSize: z.ZodOptional<z.ZodNumber>;
+    sha256Checksum: z.ZodOptional<z.ZodString>;
+    addon: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        vad: "vad";
+        tts: "tts";
+    }>>;
+}, z.core.$strip>]>;
+export type ModelDescriptor = z.infer<typeof modelDescriptorSchema>;
+export type ModelSrcInput = z.infer<typeof modelSrcInputSchema>;
+/**
+ * Schema that transforms ModelSrc to its src string
+ * Usage: modelSrcToStringSchema.parse(modelSrc)
+ */
+export declare const modelInputToSrcSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    src: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodString>;
+    hyperdriveKey: z.ZodOptional<z.ZodString>;
+    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    expectedSize: z.ZodOptional<z.ZodNumber>;
+    sha256Checksum: z.ZodOptional<z.ZodString>;
+    addon: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        vad: "vad";
+        tts: "tts";
+    }>>;
+}, z.core.$strip>]>, z.ZodTransform<string, string | {
+    src: string;
+    name?: string | undefined;
+    modelId?: string | undefined;
+    hyperdriveKey?: string | undefined;
+    hyperbeeKey?: string | undefined;
+    expectedSize?: number | undefined;
+    sha256Checksum?: string | undefined;
+    addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+}>>;
+/**
+ * Schema that transforms ModelSrc to its optional name
+ * Usage: modelSrcToNameSchema.parse(modelSrc)
+ */
+export declare const modelInputToNameSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    src: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodString>;
+    hyperdriveKey: z.ZodOptional<z.ZodString>;
+    hyperbeeKey: z.ZodOptional<z.ZodString>;
+    expectedSize: z.ZodOptional<z.ZodNumber>;
+    sha256Checksum: z.ZodOptional<z.ZodString>;
+    addon: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        vad: "vad";
+        tts: "tts";
+    }>>;
+}, z.core.$strip>]>, z.ZodTransform<string | undefined, string | {
+    src: string;
+    name?: string | undefined;
+    modelId?: string | undefined;
+    hyperdriveKey?: string | undefined;
+    hyperbeeKey?: string | undefined;
+    expectedSize?: number | undefined;
+    sha256Checksum?: string | undefined;
+    addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+}>>;
+//# sourceMappingURL=model-src-utils.d.ts.map

package/dist/schemas/model-src-utils.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export const modelDescriptorSchema = z.object({
+    src: z.string(),
+    name: z.string().optional(),
+    modelId: z.string().optional(),
+    hyperdriveKey: z.string().optional(),
+    hyperbeeKey: z.string().optional(),
+    expectedSize: z.number().optional(),
+    sha256Checksum: z.string().optional(),
+    addon: z
+        .enum(["llm", "whisper", "embeddings", "nmt", "vad", "tts"])
+        .optional(),
+});
+export const modelSrcInputSchema = z.union([z.string(), modelDescriptorSchema]);
+/**
+ * Schema that transforms ModelSrc to its src string
+ * Usage: modelSrcToStringSchema.parse(modelSrc)
+ */
+export const modelInputToSrcSchema = modelSrcInputSchema.transform((modelSrc) => {
+    return typeof modelSrc === "string" ? modelSrc : modelSrc.src;
+});
+/**
+ * Schema that transforms ModelSrc to its optional name
+ * Usage: modelSrcToNameSchema.parse(modelSrc)
+ */
+export const modelInputToNameSchema = modelSrcInputSchema.transform((modelSrc) => {
+    if (typeof modelSrc === "object" && "name" in modelSrc) {
+        return typeof modelSrc.name === "string" ? modelSrc.name : undefined;
+    }
+    return undefined;
+});

package/dist/schemas/sdk-errors-client.d.ts

@@ -0,0 +1,25 @@
+import { type ErrorCodesMap } from "@qvac/error";
+export declare const SDK_CLIENT_ERROR_CODES: {
+    readonly INVALID_RESPONSE_TYPE: 50001;
+    readonly INVALID_OPERATION_IN_RESPONSE: 50002;
+    readonly STREAM_ENDED_WITHOUT_RESPONSE: 50003;
+    readonly NO_DATA_RECEIVED: 50004;
+    readonly INVALID_AUDIO_CHUNK_TYPE: 50005;
+    readonly INVALID_TOOLS_ARRAY: 50006;
+    readonly INVALID_TOOL_SCHEMA: 50007;
+    readonly RPC_NO_HANDLER: 50200;
+    readonly RPC_REQUEST_NOT_SENT: 50201;
+    readonly RPC_RESPONSE_STREAM_NOT_CREATED: 50202;
+    readonly RPC_CONNECTION_FAILED: 50203;
+    readonly UNKNOWN_REQUEST_TYPE: 50204;
+    readonly PROVIDER_START_FAILED: 50400;
+    readonly PROVIDER_STOP_FAILED: 50401;
+    readonly DELEGATE_NO_FINAL_RESPONSE: 50402;
+    readonly DELEGATE_PROVIDER_ERROR: 50403;
+    readonly DELEGATE_CONNECTION_FAILED: 50404;
+    readonly SDK_NOT_FOUND_IN_NODE_MODULES: 50600;
+    readonly WORKER_FILE_NOT_FOUND: 50601;
+};
+declare const clientErrorDefinitions: ErrorCodesMap;
+export { clientErrorDefinitions as SDK_CLIENT_ERROR_DEFINITIONS };
+//# sourceMappingURL=sdk-errors-client.d.ts.map

package/dist/schemas/sdk-errors-client.js

@@ -0,0 +1,111 @@
+import { addCodes } from "@qvac/error";
+// Client-side error codes (50,001-52,000 range for this SDK)
+export const SDK_CLIENT_ERROR_CODES = {
+    // Response Validation Errors (50,001-50,199)
+    INVALID_RESPONSE_TYPE: 50001,
+    INVALID_OPERATION_IN_RESPONSE: 50002,
+    STREAM_ENDED_WITHOUT_RESPONSE: 50003,
+    NO_DATA_RECEIVED: 50004,
+    INVALID_AUDIO_CHUNK_TYPE: 50005,
+    INVALID_TOOLS_ARRAY: 50006,
+    INVALID_TOOL_SCHEMA: 50007,
+    // RPC Communication Errors (50,200-50,399)
+    RPC_NO_HANDLER: 50200,
+    RPC_REQUEST_NOT_SENT: 50201,
+    RPC_RESPONSE_STREAM_NOT_CREATED: 50202,
+    RPC_CONNECTION_FAILED: 50203,
+    UNKNOWN_REQUEST_TYPE: 50204,
+    // Provider/Delegation Errors (50,400-50,599)
+    PROVIDER_START_FAILED: 50400,
+    PROVIDER_STOP_FAILED: 50401,
+    DELEGATE_NO_FINAL_RESPONSE: 50402,
+    DELEGATE_PROVIDER_ERROR: 50403,
+    DELEGATE_CONNECTION_FAILED: 50404,
+    // Build/Bundle Errors (50,600-50,799)
+    SDK_NOT_FOUND_IN_NODE_MODULES: 50600,
+    WORKER_FILE_NOT_FOUND: 50601,
+};
+const clientErrorDefinitions = {
+    // Response Validation Errors (50,001-50,199)
+    [SDK_CLIENT_ERROR_CODES.INVALID_RESPONSE_TYPE]: {
+        name: "INVALID_RESPONSE_TYPE",
+        message: (expected) => `Invalid response type received, expected: ${expected}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.INVALID_OPERATION_IN_RESPONSE]: {
+        name: "INVALID_OPERATION_IN_RESPONSE",
+        message: "Invalid operation type in response",
+    },
+    [SDK_CLIENT_ERROR_CODES.STREAM_ENDED_WITHOUT_RESPONSE]: {
+        name: "STREAM_ENDED_WITHOUT_RESPONSE",
+        message: "Stream ended without receiving final response",
+    },
+    [SDK_CLIENT_ERROR_CODES.NO_DATA_RECEIVED]: {
+        name: "NO_DATA_RECEIVED",
+        message: "No data received from request",
+    },
+    [SDK_CLIENT_ERROR_CODES.INVALID_AUDIO_CHUNK_TYPE]: {
+        name: "INVALID_AUDIO_CHUNK_TYPE",
+        message: "Invalid audio chunk type received",
+    },
+    [SDK_CLIENT_ERROR_CODES.INVALID_TOOLS_ARRAY]: {
+        name: "INVALID_TOOLS_ARRAY",
+        message: "Invalid tools array provided",
+    },
+    [SDK_CLIENT_ERROR_CODES.INVALID_TOOL_SCHEMA]: {
+        name: "INVALID_TOOL_SCHEMA",
+        message: (details) => `Invalid tool schema: ${details}`,
+    },
+    // RPC Communication Errors (50,200-50,399)
+    [SDK_CLIENT_ERROR_CODES.RPC_NO_HANDLER]: {
+        name: "RPC_NO_HANDLER",
+        message: (requestType) => `No handler function registered for request type: ${requestType}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.RPC_REQUEST_NOT_SENT]: {
+        name: "RPC_REQUEST_NOT_SENT",
+        message: "Cannot perform operation - request has not been sent yet",
+    },
+    [SDK_CLIENT_ERROR_CODES.RPC_RESPONSE_STREAM_NOT_CREATED]: {
+        name: "RPC_RESPONSE_STREAM_NOT_CREATED",
+        message: "Cannot perform operation - response stream not created",
+    },
+    [SDK_CLIENT_ERROR_CODES.RPC_CONNECTION_FAILED]: {
+        name: "RPC_CONNECTION_FAILED",
+        message: (details) => `RPC connection failed: ${details}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.UNKNOWN_REQUEST_TYPE]: {
+        name: "UNKNOWN_REQUEST_TYPE",
+        message: "Unknown request type received",
+    },
+    // Provider/Delegation Errors (50,400-50,599)
+    [SDK_CLIENT_ERROR_CODES.PROVIDER_START_FAILED]: {
+        name: "PROVIDER_START_FAILED",
+        message: (details) => `Failed to start provider${details ? `: ${details}` : ""}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.PROVIDER_STOP_FAILED]: {
+        name: "PROVIDER_STOP_FAILED",
+        message: (details) => `Failed to stop provider${details ? `: ${details}` : ""}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.DELEGATE_NO_FINAL_RESPONSE]: {
+        name: "DELEGATE_NO_FINAL_RESPONSE",
+        message: "No final response received from delegated provider",
+    },
+    [SDK_CLIENT_ERROR_CODES.DELEGATE_PROVIDER_ERROR]: {
+        name: "DELEGATE_PROVIDER_ERROR",
+        message: (details) => `Delegated provider error: ${details}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.DELEGATE_CONNECTION_FAILED]: {
+        name: "DELEGATE_CONNECTION_FAILED",
+        message: (details) => `Failed to connect to delegated provider: ${details}`,
+    },
+    // Build/Bundle Errors (50,600-50,799)
+    [SDK_CLIENT_ERROR_CODES.SDK_NOT_FOUND_IN_NODE_MODULES]: {
+        name: "SDK_NOT_FOUND_IN_NODE_MODULES",
+        message: "@qvac/sdk not found in node_modules",
+    },
+    [SDK_CLIENT_ERROR_CODES.WORKER_FILE_NOT_FOUND]: {
+        name: "WORKER_FILE_NOT_FOUND",
+        message: (workerPath) => `Worker file not found at ${workerPath}`,
+    },
+};
+addCodes(clientErrorDefinitions, { name: "qvac-sdk-client", version: "1.1.0" });
+export { clientErrorDefinitions as SDK_CLIENT_ERROR_DEFINITIONS };

package/dist/schemas/sdk-errors-server.d.ts

@@ -0,0 +1,55 @@
+import { type ErrorCodesMap } from "@qvac/error";
+export declare const SDK_SERVER_ERROR_CODES: {
+    readonly MODEL_ALREADY_REGISTERED: 52001;
+    readonly MODEL_NOT_FOUND: 52002;
+    readonly MODEL_NOT_LOADED: 52003;
+    readonly MODEL_IS_DELEGATED: 52004;
+    readonly UNKNOWN_MODEL_TYPE: 52005;
+    readonly MODEL_LOAD_FAILED: 52200;
+    readonly MODEL_FILE_NOT_FOUND: 52201;
+    readonly MODEL_FILE_NOT_FOUND_IN_DIR: 52202;
+    readonly MODEL_FILE_LOCATE_FAILED: 52203;
+    readonly PROJECTION_MODEL_REQUIRED: 52204;
+    readonly VAD_MODEL_REQUIRED: 52205;
+    readonly TTS_CONFIG_MODEL_REQUIRED: 52206;
+    readonly ESPEAK_DATA_PATH_REQUIRED: 52207;
+    readonly MODEL_UNLOAD_FAILED: 52400;
+    readonly EMBED_FAILED: 52401;
+    readonly EMBED_NO_EMBEDDINGS: 52402;
+    readonly TRANSCRIPTION_FAILED: 52403;
+    readonly AUDIO_FILE_NOT_FOUND: 52404;
+    readonly TRANSLATION_FAILED: 52405;
+    readonly COMPLETION_FAILED: 52406;
+    readonly ATTACHMENT_NOT_FOUND: 52407;
+    readonly CANCEL_FAILED: 52408;
+    readonly TEXT_TO_SPEECH_FAILED: 52409;
+    readonly RAG_SAVE_FAILED: 52800;
+    readonly RAG_SEARCH_FAILED: 52801;
+    readonly RAG_DELETE_FAILED: 52802;
+    readonly RAG_UNKNOWN_OPERATION: 52803;
+    readonly RAG_HYPERDB_FAILED: 52804;
+    readonly RAG_WORKSPACE_MODEL_MISMATCH: 52805;
+    readonly FILE_NOT_FOUND: 53000;
+    readonly DOWNLOAD_CANCELLED: 53001;
+    readonly CHECKSUM_VALIDATION_FAILED: 53002;
+    readonly HTTP_ERROR: 53003;
+    readonly NO_RESPONSE_BODY: 53004;
+    readonly RESPONSE_BODY_NOT_READABLE: 53005;
+    readonly NO_BLOB_FOUND: 53006;
+    readonly DOWNLOAD_ASSET_FAILED: 53007;
+    readonly SEEDING_NOT_SUPPORTED: 53008;
+    readonly HYPERDRIVE_DOWNLOAD_FAILED: 53009;
+    readonly DELETE_CACHE_FAILED: 53200;
+    readonly INVALID_DELETE_CACHE_PARAMS: 53201;
+    readonly CACHE_DIR_NOT_ABSOLUTE: 53202;
+    readonly CACHE_DIR_NOT_WRITABLE: 53203;
+    readonly SET_CONFIG_FAILED: 53350;
+    readonly FFMPEG_NOT_AVAILABLE: 53500;
+    readonly AUDIO_PLAYER_FAILED: 53501;
+    readonly INVALID_AUDIO_CHUNK_TYPE: 53502;
+    readonly DELEGATE_NO_FINAL_RESPONSE: 53700;
+    readonly DELEGATE_CONNECTION_FAILED: 53701;
+};
+declare const serverErrorDefinitions: ErrorCodesMap;
+export { serverErrorDefinitions as SDK_SERVER_ERROR_DEFINITIONS };
+//# sourceMappingURL=sdk-errors-server.d.ts.map