@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/schemas/load-model.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+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([
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("llm"),
+        modelConfig: llmConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        projectionModelSrc: z.string().optional(),
+        delegate: delegateSchema,
+        toolFormat: z.enum(["json", "xml"]).default("json"),
+    }),
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("whisper"),
+        modelConfig: whisperConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        vadModelSrc: z.string().optional(),
+        delegate: delegateSchema,
+    }),
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("embeddings"),
+        modelConfig: embedConfigSchema.partial().strict().optional(),
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
+    z.object({
+        modelSrc: z.string(),
+        modelType: z.literal("nmt"),
+        modelConfig: nmtConfigSchema,
+        seed: z.boolean().optional(),
+        delegate: delegateSchema,
+    }),
+])
+    .transform((data) => ({
+    ...data,
+    seed: data.seed ?? false,
+}));
+const commonModelConfigSchema = z.object({
+    type: z.literal("loadModel"),
+    modelSrc: z.string(),
+    projectionModelSrc: z.string().optional(),
+    vadModelSrc: z.string().optional(),
+    withProgress: z.boolean().optional(),
+    seed: z.boolean().optional(),
+    delegate: delegateSchema,
+});
+// Request schemas for each model type
+export const loadLlmModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("llm"),
+    modelConfig: llmConfigSchema,
+});
+export const loadWhisperModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("whisper"),
+    modelConfig: whisperConfigSchema,
+});
+export const loadEmbeddingsModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("embeddings"),
+    modelConfig: embedConfigSchema,
+});
+export const loadNmtModelRequestSchema = commonModelConfigSchema.extend({
+    modelType: z.literal("nmt"),
+    modelConfig: nmtConfigSchema,
+});
+// Union of all load model request types
+export const loadModelRequestSchema = z
+    .discriminatedUnion("modelType", [
+    loadLlmModelRequestSchema,
+    loadWhisperModelRequestSchema,
+    loadEmbeddingsModelRequestSchema,
+    loadNmtModelRequestSchema,
+])
+    .transform((data) => ({
+    ...data,
+    seed: data.seed ?? false,
+}));
+export const loadModelResponseSchema = z.object({
+    type: z.literal("loadModel"),
+    success: z.boolean(),
+    modelId: z.string().optional(),
+    error: z.string().optional(),
+});
+export const modelProgressUpdateSchema = z.object({
+    type: z.literal("modelProgress"),
+    downloaded: z.number(),
+    total: z.number(),
+    percentage: z.number(),
+    downloadKey: z.string(),
+});
+export const hyperdriveUrlSchema = z
+    .string()
+    .regex(/^pear:\/\/[0-9a-fA-F]{64}\/(.+)$/, "Invalid hyperdrive URL. Expected format: pear://64-char-hex-key/path/to/model.gguf")
+    .transform((url) => {
+    const match = url.match(/^pear:\/\/([0-9a-fA-F]{64})\/(.+)$/);
+    return { key: match[1], path: match[2] };
+});
+export const loadModelServerParamsSchema = z.object({
+    modelId: z.string(),
+    modelPath: z.string(),
+    options: loadModelOptionsSchema,
+    projectionModelPath: z.string().optional(),
+    vadModelPath: z.string().optional(),
+});

package/dist/schemas/logging-stream.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+declare const loggingParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+}, z.core.$strip>;
+export declare const loggingStreamRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    type: z.ZodLiteral<"loggingStream">;
+}, z.core.$strip>;
+export declare const loggingStreamResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"loggingStream">;
+    modelId: z.ZodString;
+    level: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        info: "info";
+        debug: "debug";
+        off: "off";
+    }>;
+    namespace: z.ZodString;
+    message: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type LoggingParams = z.infer<typeof loggingParamsSchema>;
+export type LoggingStreamRequest = z.infer<typeof loggingStreamRequestSchema>;
+export type LoggingStreamResponse = z.infer<typeof loggingStreamResponseSchema>;
+export {};
+//# sourceMappingURL=logging-stream.d.ts.map

package/dist/schemas/logging-stream.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+const logLevelValues = ["error", "warn", "info", "debug"];
+const loggingParamsSchema = z.object({
+    modelId: z.string(),
+});
+export const loggingStreamRequestSchema = loggingParamsSchema.extend({
+    type: z.literal("loggingStream"),
+});
+export const loggingStreamResponseSchema = z.object({
+    type: z.literal("loggingStream"),
+    modelId: z.string(),
+    level: z.enum(logLevelValues),
+    namespace: z.string(),
+    message: z.string(),
+    timestamp: z.number(),
+});

package/dist/schemas/ping.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const pingRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>;
+export declare const pingResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    number: z.ZodNumber;
+}, z.core.$strip>;
+export type PingRequest = z.infer<typeof pingRequestSchema>;
+export type PingResponse = z.infer<typeof pingResponseSchema>;
+//# sourceMappingURL=ping.d.ts.map

package/dist/schemas/ping.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const pingRequestSchema = z.object({
+    type: z.literal("ping"),
+});
+export const pingResponseSchema = z.object({
+    type: z.literal("pong"),
+    number: z.number(),
+});

package/dist/schemas/provide.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const firewallConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>>;
+    publicKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const provideParamsSchema: z.ZodObject<{
+    topic: z.ZodString;
+    firewall: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        publicKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const provideRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"provide">;
+    topic: z.ZodString;
+    firewall: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>>;
+        publicKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export declare const provideResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"provide">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    publicKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const envSchema: z.ZodObject<{
+    QVAC_HYPERSWARM_SEED: z.ZodString;
+}, z.core.$strip>;
+export type FirewallConfig = z.infer<typeof firewallConfigSchema>;
+export type ProvideParams = z.infer<typeof provideParamsSchema>;
+export type ProvideRequest = z.infer<typeof provideRequestSchema>;
+export type ProvideResponse = z.infer<typeof provideResponseSchema>;
+//# sourceMappingURL=provide.d.ts.map

package/dist/schemas/provide.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const firewallConfigSchema = z.object({
+    mode: z.enum(["allow", "deny"]).default("allow"),
+    publicKeys: z.array(z.string()).default([]),
+});
+export const provideParamsSchema = z
+    .object({
+    topic: z.string(),
+    firewall: firewallConfigSchema.optional(),
+})
+    .strict();
+export const provideRequestSchema = provideParamsSchema.extend({
+    type: z.literal("provide"),
+    topic: z.string(),
+    firewall: firewallConfigSchema.optional(),
+});
+export const provideResponseSchema = z.object({
+    type: z.literal("provide"),
+    success: z.boolean(),
+    error: z.string().optional(),
+    publicKey: z.string().optional(),
+});
+export const envSchema = z.object({
+    QVAC_HYPERSWARM_SEED: z.string(),
+});

package/dist/schemas/rag.d.ts

@@ -0,0 +1,159 @@
+import { z } from "zod";
+declare const ragSaveEmbeddingsResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        fulfilled: "fulfilled";
+        rejected: "rejected";
+    }>;
+    id: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const searchResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+declare const ragSaveEmbeddingsParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    documents: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    chunk: z.ZodDefault<z.ZodBoolean>;
+    chunkOpts: z.ZodOptional<z.ZodObject<{
+        chunkSize: z.ZodOptional<z.ZodNumber>;
+        chunkOverlap: z.ZodOptional<z.ZodNumber>;
+        chunkStrategy: z.ZodOptional<z.ZodEnum<{
+            character: "character";
+            paragraph: "paragraph";
+        }>>;
+        splitStrategy: z.ZodOptional<z.ZodEnum<{
+            character: "character";
+            word: "word";
+            sentence: "sentence";
+            line: "line";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ragSaveEmbeddingsOperationSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    documents: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    chunk: z.ZodDefault<z.ZodBoolean>;
+    chunkOpts: z.ZodOptional<z.ZodObject<{
+        chunkSize: z.ZodOptional<z.ZodNumber>;
+        chunkOverlap: z.ZodOptional<z.ZodNumber>;
+        chunkStrategy: z.ZodOptional<z.ZodEnum<{
+            character: "character";
+            paragraph: "paragraph";
+        }>>;
+        splitStrategy: z.ZodOptional<z.ZodEnum<{
+            character: "character";
+            word: "word";
+            sentence: "sentence";
+            line: "line";
+        }>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"rag">;
+    operation: z.ZodLiteral<"saveEmbeddings">;
+}, z.core.$strip>;
+declare const ragSearchParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    query: z.ZodString;
+    topK: z.ZodOptional<z.ZodNumber>;
+    n: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ragSearchOperationSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    query: z.ZodString;
+    type: z.ZodLiteral<"rag">;
+    operation: z.ZodLiteral<"search">;
+    topK: z.ZodDefault<z.ZodNumber>;
+    n: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const deleteEmbeddingsParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ragDeleteEmbeddingsOperationSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    ids: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"rag">;
+    operation: z.ZodLiteral<"deleteEmbeddings">;
+}, z.core.$strip>;
+export declare const ragRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    documents: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    chunk: z.ZodDefault<z.ZodBoolean>;
+    chunkOpts: z.ZodOptional<z.ZodObject<{
+        chunkSize: z.ZodOptional<z.ZodNumber>;
+        chunkOverlap: z.ZodOptional<z.ZodNumber>;
+        chunkStrategy: z.ZodOptional<z.ZodEnum<{
+            character: "character";
+            paragraph: "paragraph";
+        }>>;
+        splitStrategy: z.ZodOptional<z.ZodEnum<{
+            character: "character";
+            word: "word";
+            sentence: "sentence";
+            line: "line";
+        }>>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"rag">;
+    operation: z.ZodLiteral<"saveEmbeddings">;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    query: z.ZodString;
+    type: z.ZodLiteral<"rag">;
+    operation: z.ZodLiteral<"search">;
+    topK: z.ZodDefault<z.ZodNumber>;
+    n: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    workspace: z.ZodOptional<z.ZodString>;
+    ids: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"rag">;
+    operation: z.ZodLiteral<"deleteEmbeddings">;
+}, z.core.$strip>], "operation">;
+export declare const ragResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"rag">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    operation: z.ZodLiteral<"saveEmbeddings">;
+    processed: z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            fulfilled: "fulfilled";
+            rejected: "rejected";
+        }>;
+        id: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    droppedIndices: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"rag">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    operation: z.ZodLiteral<"search">;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        score: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"rag">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    operation: z.ZodLiteral<"deleteEmbeddings">;
+}, z.core.$strip>], "operation">;
+export type RagRequest = z.infer<typeof ragRequestSchema>;
+export type RagResponse = z.infer<typeof ragResponseSchema>;
+export type RagSaveEmbeddingsResult = z.infer<typeof ragSaveEmbeddingsResultSchema>;
+export type RagSearchResult = z.infer<typeof searchResultSchema>;
+export type RagSaveEmbeddingsParams = z.infer<typeof ragSaveEmbeddingsParamsSchema>;
+export type RagDeleteEmbeddingsParams = z.infer<typeof deleteEmbeddingsParamsSchema>;
+export type RagSearchParams = z.infer<typeof ragSearchParamsSchema>;
+export {};
+//# sourceMappingURL=rag.d.ts.map

package/dist/schemas/rag.js

@@ -0,0 +1,78 @@
+import { z } from "zod";
+// ============== Common Types ==============
+const llmChunkOptsSchema = z.object({
+    chunkSize: z.number().optional(),
+    chunkOverlap: z.number().optional(),
+    chunkStrategy: z.enum(["character", "paragraph"]).optional(),
+    splitStrategy: z.enum(["character", "word", "sentence", "line"]).optional(),
+});
+const ragSaveEmbeddingsResultSchema = z.object({
+    status: z.enum(["fulfilled", "rejected"]),
+    id: z.string().optional(),
+    error: z.string().optional(),
+});
+const searchResultSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    score: z.number(),
+});
+// ============== Request Schema ==============
+const ragBaseSchema = z.object({
+    modelId: z.string(),
+    workspace: z.string().optional(), // Optional workspace for isolated storage
+});
+const ragSaveEmbeddingsParamsSchema = ragBaseSchema.extend({
+    documents: z.union([z.string(), z.array(z.string())]),
+    chunk: z.boolean().default(false),
+    chunkOpts: llmChunkOptsSchema.optional(),
+});
+export const ragSaveEmbeddingsOperationSchema = ragSaveEmbeddingsParamsSchema.extend({
+    type: z.literal("rag"),
+    operation: z.literal("saveEmbeddings"),
+});
+const ragSearchParamsSchema = ragBaseSchema.extend({
+    query: z.string().min(1, "Query cannot be empty"),
+    topK: z.number().positive().optional(),
+    n: z.number().positive().optional(),
+});
+export const ragSearchOperationSchema = ragSearchParamsSchema.extend({
+    type: z.literal("rag"),
+    operation: z.literal("search"),
+    topK: z.number().positive().default(5),
+    n: z.number().positive().default(3),
+});
+const deleteEmbeddingsParamsSchema = ragBaseSchema.extend({
+    ids: z.array(z.string()).min(1, "At least one ID must be provided"),
+});
+export const ragDeleteEmbeddingsOperationSchema = deleteEmbeddingsParamsSchema.extend({
+    type: z.literal("rag"),
+    operation: z.literal("deleteEmbeddings"),
+});
+export const ragRequestSchema = z.discriminatedUnion("operation", [
+    ragSaveEmbeddingsOperationSchema,
+    ragSearchOperationSchema,
+    ragDeleteEmbeddingsOperationSchema,
+]);
+// ============== Response Schema ==============
+const ragResponseBaseSchema = z.object({
+    type: z.literal("rag"),
+    success: z.boolean(),
+    error: z.string().optional(),
+});
+const ragSaveEmbeddingsResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("saveEmbeddings"),
+    processed: z.array(ragSaveEmbeddingsResultSchema),
+    droppedIndices: z.array(z.number()),
+});
+const ragSearchResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("search"),
+    results: z.array(searchResultSchema),
+});
+const ragDeleteEmbeddingsResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("deleteEmbeddings"),
+});
+export const ragResponseSchema = z.discriminatedUnion("operation", [
+    ragSaveEmbeddingsResponseSchema,
+    ragSearchResponseSchema,
+    ragDeleteEmbeddingsResponseSchema,
+]);

package/dist/schemas/transcription.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare const transcribeParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    audioChunk: z.ZodString;
+}, z.core.$strip>;
+export declare const transcribeStreamRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    audioChunk: z.ZodString;
+    type: z.ZodLiteral<"transcribeStream">;
+}, z.core.$strip>;
+export declare const transcribeStreamResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"transcribeStream">;
+    text: z.ZodOptional<z.ZodString>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TranscribeParams = z.infer<typeof transcribeParamsSchema>;
+export type TranscribeClientParams = {
+    modelId: string;
+    audioChunk: string | Buffer;
+};
+export type TranscribeStreamRequest = z.infer<typeof transcribeStreamRequestSchema>;
+export type TranscribeStreamResponse = z.infer<typeof transcribeStreamResponseSchema>;
+//# sourceMappingURL=transcription.d.ts.map

package/dist/schemas/transcription.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export const transcribeParamsSchema = z.object({
+    modelId: z.string(),
+    audioChunk: z.string(), // Base64 encoded audio chunk or file path
+});
+// Streaming Transcribe Schema (for real-time audio streaming)
+export const transcribeStreamRequestSchema = transcribeParamsSchema.extend({
+    type: z.literal("transcribeStream"),
+});
+export const transcribeStreamResponseSchema = z.object({
+    type: z.literal("transcribeStream"),
+    text: z.string().optional(),
+    done: z.boolean().optional(),
+    error: z.string().optional(),
+});

package/dist/schemas/translate.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import type { NmtLanguage } from "./translation-config";
+declare const translateParamsBaseSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+}, z.core.$strip>;
+declare const translateParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+    modelType: z.ZodLiteral<"nmt">;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+    modelType: z.ZodLiteral<"llm">;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "modelType">;
+export declare const translationStatsSchema: z.ZodObject<{
+    processedTokens: z.ZodNumber;
+    processingTime: z.ZodNumber;
+}, z.core.$strip>;
+export declare const translateRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+    modelType: z.ZodLiteral<"nmt">;
+    type: z.ZodLiteral<"translate">;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+    modelType: z.ZodLiteral<"llm">;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"translate">;
+}, z.core.$strip>]>;
+export declare const translateServerParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+    modelType: z.ZodLiteral<"nmt">;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    stream: z.ZodBoolean;
+    modelType: z.ZodLiteral<"llm">;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "modelType">;
+export declare const translateResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"translate">;
+    token: z.ZodString;
+    done: z.ZodOptional<z.ZodBoolean>;
+    stats: z.ZodOptional<z.ZodObject<{
+        processedTokens: z.ZodNumber;
+        processingTime: z.ZodNumber;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TranslateParams = z.infer<typeof translateParamsSchema>;
+export type TranslateRequest = z.infer<typeof translateRequestSchema>;
+export type TranslateResponse = z.infer<typeof translateResponseSchema>;
+export type TranslationStats = z.infer<typeof translationStatsSchema>;
+type TranslateParamsBase = z.input<typeof translateParamsBaseSchema>;
+type TranslateParamsNmt = TranslateParamsBase & {
+    modelType: "nmt";
+};
+type TranslateParamsLlm = TranslateParamsBase & {
+    modelType: "llm";
+    from?: NmtLanguage | (string & {});
+    to: NmtLanguage | (string & {});
+    context?: string;
+};
+export type TranslateClientParams = TranslateParamsNmt | TranslateParamsLlm;
+export {};
+//# sourceMappingURL=translate.d.ts.map

package/dist/schemas/translate.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+const translateParamsBaseSchema = z.object({
+    modelId: z.string(),
+    text: z.string().min(1, "Text cannot be empty"),
+    stream: z.boolean(),
+});
+const translateParamsNmtSchema = translateParamsBaseSchema.extend({
+    modelType: z.literal("nmt"),
+});
+const translateParamsLlmSchema = translateParamsBaseSchema.extend({
+    modelType: z.literal("llm"),
+    from: z.string().optional(),
+    to: z.string(),
+    context: z.string().optional(),
+});
+const translateParamsSchema = z.discriminatedUnion("modelType", [
+    translateParamsNmtSchema,
+    translateParamsLlmSchema,
+]);
+export const translationStatsSchema = z.object({
+    processedTokens: z.number(),
+    processingTime: z.number(),
+});
+export const translateRequestSchema = z.union([
+    translateParamsNmtSchema.extend({ type: z.literal("translate") }),
+    translateParamsLlmSchema.extend({ type: z.literal("translate") }),
+]);
+// Validates the translate server args and returns the model info
+export const translateServerParamsSchema = translateParamsSchema
+    .refine((data) => data.modelType && ["nmt", "llm"].includes(data.modelType), {
+    message: "Model type is not compatible with translation. Only LLM and NMT models are supported.",
+})
+    .refine((data) => !(data.modelType === "llm" && (!data.from || !data.to)), {
+    message: "Both 'from' and 'to' languages are required for LLM translation models",
+});
+export const translateResponseSchema = z.object({
+    type: z.literal("translate"),
+    token: z.string(),
+    done: z.boolean().optional(),
+    stats: translationStatsSchema.optional(),
+    error: z.string().optional(),
+});