@qvac/sdk 0.14.1 → 0.15.0

package/dist/schemas/batch-completion-stream.d.ts

@@ -0,0 +1,463 @@
+import { z } from 'zod';
+import { type CompletionEvent, type CompletionFinal, type CompletionStats } from './completion-event';
+import { type McpClientInput } from './mcp-adapter';
+export declare const batchPromptSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    generationParams: z.ZodOptional<z.ZodObject<{
+        temp: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        predict: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        repeat_penalty: z.ZodOptional<z.ZodNumber>;
+        reasoning_budget: z.ZodOptional<z.ZodNumber>;
+        remove_thinking_from_context: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"json_object">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"json_schema">;
+        json_schema: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            strict: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                    integer: "integer";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    mcp: z.ZodOptional<z.ZodArray<z.ZodCustom<McpClientInput, McpClientInput>>>;
+}, z.core.$strict>;
+declare const batchPromptStreamSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    generationParams: z.ZodOptional<z.ZodObject<{
+        temp: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        predict: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        repeat_penalty: z.ZodOptional<z.ZodNumber>;
+        reasoning_budget: z.ZodOptional<z.ZodNumber>;
+        remove_thinking_from_context: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"json_object">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"json_schema">;
+        json_schema: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            strict: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                    integer: "integer";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export declare const batchCompletionClientParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    prompts: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        history: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            content: z.ZodString;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        generationParams: z.ZodOptional<z.ZodObject<{
+            temp: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            predict: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            repeat_penalty: z.ZodOptional<z.ZodNumber>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+            remove_thinking_from_context: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                strict: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "type">>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            name: z.ZodString;
+            description: z.ZodString;
+            parameters: z.ZodObject<{
+                type: z.ZodLiteral<"object">;
+                properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    type: z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        array: "array";
+                        integer: "integer";
+                    }>;
+                    description: z.ZodOptional<z.ZodString>;
+                    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        mcp: z.ZodOptional<z.ZodArray<z.ZodCustom<McpClientInput, McpClientInput>>>;
+    }, z.core.$strict>>;
+    stream: z.ZodOptional<z.ZodBoolean>;
+    captureThinking: z.ZodOptional<z.ZodBoolean>;
+    emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
+    }>>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const batchCompletionStreamRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    stream: z.ZodOptional<z.ZodBoolean>;
+    captureThinking: z.ZodOptional<z.ZodBoolean>;
+    emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
+    }>>;
+    requestId: z.ZodOptional<z.ZodString>;
+    prompts: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        history: z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            content: z.ZodString;
+            attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        generationParams: z.ZodOptional<z.ZodObject<{
+            temp: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            top_k: z.ZodOptional<z.ZodNumber>;
+            predict: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodNumber>;
+            frequency_penalty: z.ZodOptional<z.ZodNumber>;
+            presence_penalty: z.ZodOptional<z.ZodNumber>;
+            repeat_penalty: z.ZodOptional<z.ZodNumber>;
+            reasoning_budget: z.ZodOptional<z.ZodNumber>;
+            remove_thinking_from_context: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                strict: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "type">>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            name: z.ZodString;
+            description: z.ZodString;
+            parameters: z.ZodObject<{
+                type: z.ZodLiteral<"object">;
+                properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                    type: z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        object: "object";
+                        array: "array";
+                        integer: "integer";
+                    }>;
+                    description: z.ZodOptional<z.ZodString>;
+                    enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"batchCompletionStream">;
+}, z.core.$strict>;
+export declare const batchCompletionEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    event: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"contentDelta">;
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"rawDelta">;
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinkingDelta">;
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"toolCall">;
+        seq: z.ZodNumber;
+        call: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            raw: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"toolError">;
+        seq: z.ZodNumber;
+        error: z.ZodObject<{
+            code: z.ZodEnum<{
+                PARSE_ERROR: "PARSE_ERROR";
+                VALIDATION_ERROR: "VALIDATION_ERROR";
+                UNKNOWN_TOOL: "UNKNOWN_TOOL";
+            }>;
+            message: z.ZodString;
+            raw: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"completionStats">;
+        seq: z.ZodNumber;
+        stats: z.ZodObject<{
+            timeToFirstToken: z.ZodOptional<z.ZodNumber>;
+            tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+            cacheTokens: z.ZodOptional<z.ZodNumber>;
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            generatedTokens: z.ZodOptional<z.ZodNumber>;
+            avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
+            backendDevice: z.ZodOptional<z.ZodEnum<{
+                gpu: "gpu";
+                cpu: "cpu";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"completionDone">;
+        seq: z.ZodNumber;
+        stopReason: z.ZodLiteral<"error">;
+        error: z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strip>;
+        raw: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"completionDone">;
+        seq: z.ZodNumber;
+        stopReason: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            eos: "eos";
+            length: "length";
+            stopSequence: "stopSequence";
+        }>>;
+        raw: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export declare const batchCompletionStreamResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"batchCompletionStream">;
+    done: z.ZodOptional<z.ZodBoolean>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        event: z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"contentDelta">;
+            seq: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"rawDelta">;
+            seq: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"thinkingDelta">;
+            seq: z.ZodNumber;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"toolCall">;
+            seq: z.ZodNumber;
+            call: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                raw: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"toolError">;
+            seq: z.ZodNumber;
+            error: z.ZodObject<{
+                code: z.ZodEnum<{
+                    PARSE_ERROR: "PARSE_ERROR";
+                    VALIDATION_ERROR: "VALIDATION_ERROR";
+                    UNKNOWN_TOOL: "UNKNOWN_TOOL";
+                }>;
+                message: z.ZodString;
+                raw: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"completionStats">;
+            seq: z.ZodNumber;
+            stats: z.ZodObject<{
+                timeToFirstToken: z.ZodOptional<z.ZodNumber>;
+                tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+                cacheTokens: z.ZodOptional<z.ZodNumber>;
+                promptTokens: z.ZodOptional<z.ZodNumber>;
+                generatedTokens: z.ZodOptional<z.ZodNumber>;
+                avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
+                backendDevice: z.ZodOptional<z.ZodEnum<{
+                    gpu: "gpu";
+                    cpu: "cpu";
+                }>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"completionDone">;
+            seq: z.ZodNumber;
+            stopReason: z.ZodLiteral<"error">;
+            error: z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strip>;
+            raw: z.ZodOptional<z.ZodObject<{
+                fullText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"completionDone">;
+            seq: z.ZodNumber;
+            stopReason: z.ZodOptional<z.ZodEnum<{
+                cancelled: "cancelled";
+                eos: "eos";
+                length: "length";
+                stopSequence: "stopSequence";
+            }>>;
+            raw: z.ZodOptional<z.ZodObject<{
+                fullText: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+    stats: z.ZodOptional<z.ZodObject<{
+        timeToFirstToken: z.ZodOptional<z.ZodNumber>;
+        tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+        cacheTokens: z.ZodOptional<z.ZodNumber>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
+        generatedTokens: z.ZodOptional<z.ZodNumber>;
+        avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
+        backendDevice: z.ZodOptional<z.ZodEnum<{
+            gpu: "gpu";
+            cpu: "cpu";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type BatchPrompt = z.infer<typeof batchPromptSchema>;
+export type BatchCompletionStreamPrompt = z.infer<typeof batchPromptStreamSchema>;
+export type BatchCompletionClientParams = z.input<typeof batchCompletionClientParamsSchema>;
+export type BatchCompletionStreamRequest = z.infer<typeof batchCompletionStreamRequestSchema>;
+export type BatchCompletionEvent = z.infer<typeof batchCompletionEventSchema>;
+export type BatchCompletionStreamResponse = z.infer<typeof batchCompletionStreamResponseSchema>;
+export type BatchCompletionResult = {
+    id: string;
+    final: CompletionFinal;
+};
+export type BatchCompletionRun = {
+    requestId: string;
+    ids: Promise<string[]>;
+    events: AsyncIterable<BatchCompletionEvent>;
+    /**
+     * Aggregate per-prompt results in prompt order. This promise is
+     * **all-or-nothing** for stream-level failures: if the batch handler
+     * throws (e.g. `ContextOverflowError`) the whole run rejects and no
+     * per-prompt finals can be recovered. For graceful terminal events such
+     * as cancellation, each `byId(id).final` settles consistently with that
+     * id's terminal state.
+     */
+    results: Promise<BatchCompletionResult[]>;
+    /**
+     * Batch-level decode stats (e.g. `avgConcurrentSeq`, aggregate token
+     * counts), reported once for the whole run. The addon does not provide
+     * per-prompt stats, so this is the only place batch metrics surface —
+     * per-prompt `final.stats` is intentionally left undefined. Resolves to
+     * `undefined` when the addon reported no stats.
+     */
+    stats: Promise<CompletionStats | undefined>;
+    byId(id: string): {
+        events: AsyncIterable<CompletionEvent>;
+        final: Promise<CompletionFinal>;
+    };
+};
+export {};
+//# sourceMappingURL=batch-completion-stream.d.ts.map

package/dist/schemas/batch-completion-stream.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { completionEventSchema, completionStatsSchema } from './completion-event.js';
+import { completionParamsSchema, generationParamsSchema, responseFormatSchema, toolDialectSchema } from './completion-stream.js';
+import {} from './mcp-adapter.js';
+import { toolSchema } from './tools.js';
+const mcpClientInputSchema = z.custom();
+const batchPromptBaseSchema = z
+    .object({
+    id: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Optional caller-supplied id used to correlate streamed chunks and final results.'),
+    history: completionParamsSchema.shape.history,
+    generationParams: generationParamsSchema
+        .optional()
+        .describe('Optional per-prompt sampling / generation parameters.'),
+    responseFormat: responseFormatSchema
+        .optional()
+        .describe('Optional per-prompt structured-output constraint.')
+})
+    .strict();
+function refineNoToolsWithStructuredOutput(data, ctx) {
+    const hasTools = (data.tools?.length ?? 0) > 0;
+    const hasMcp = (data.mcp?.length ?? 0) > 0;
+    if (data.responseFormat && data.responseFormat.type !== 'text' && (hasTools || hasMcp)) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'responseFormat (json_object/json_schema) cannot be combined with tools or mcp; tools already constrain output via their parameter schema.',
+            path: ['responseFormat']
+        });
+    }
+}
+export const batchPromptSchema = batchPromptBaseSchema
+    .extend({
+    tools: z.array(toolSchema).optional().describe('Optional per-prompt tools the model can call.'),
+    mcp: z
+        .array(mcpClientInputSchema)
+        .optional()
+        .describe('Optional per-prompt MCP clients used to source tools.')
+})
+    .strict()
+    .superRefine(refineNoToolsWithStructuredOutput);
+const batchPromptStreamSchema = batchPromptBaseSchema
+    .extend({
+    tools: z.array(toolSchema).optional().describe('Resolved per-prompt tools the model can call.')
+})
+    .strict()
+    .superRefine(refineNoToolsWithStructuredOutput);
+const batchCompletionClientParamsBaseSchema = z
+    .object({
+    modelId: z.string().describe('The identifier of the model to use for batch completion.'),
+    prompts: z
+        .array(batchPromptSchema)
+        .min(1)
+        .refine((prompts) => {
+        const ids = prompts
+            .map((prompt) => prompt.id)
+            .filter((id) => id !== undefined);
+        return new Set(ids).size === ids.length;
+    }, {
+        // Caller-supplied ids key per-prompt state on the client; dupes
+        // would silently merge two prompts' events and results.
+        message: 'Batch prompt ids must be unique.'
+    })
+        .describe('Batch prompts submitted to the addon in one run.'),
+    stream: z
+        .boolean()
+        .optional()
+        .describe('Whether to stream tokens (`true`) or return all events on completion. Defaults to true.'),
+    captureThinking: z
+        .boolean()
+        .optional()
+        .describe('When `true`, capture and emit reasoning/thinking deltas separately from content deltas.'),
+    emitRawDeltas: z
+        .boolean()
+        .optional()
+        .describe('When `true`, also emit raw per-token deltas in addition to normalized content deltas.'),
+    toolDialect: toolDialectSchema
+        .optional()
+        .describe('Override auto-detected tool-call dialect for all prompts.'),
+    requestId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Stable identifier for this in-flight batch request.')
+})
+    .strict();
+export const batchCompletionClientParamsSchema = batchCompletionClientParamsBaseSchema;
+export const batchCompletionStreamRequestSchema = batchCompletionClientParamsBaseSchema.extend({
+    prompts: z
+        .array(batchPromptStreamSchema)
+        .min(1)
+        .refine((prompts) => {
+        const ids = prompts
+            .map((prompt) => prompt.id)
+            .filter((id) => id !== undefined);
+        return new Set(ids).size === ids.length;
+    }, {
+        message: 'Batch prompt ids must be unique.'
+    })
+        .describe('Batch prompts submitted to the addon in one run.'),
+    type: z.literal('batchCompletionStream')
+});
+export const batchCompletionEventSchema = z
+    .object({
+    id: z.string(),
+    event: completionEventSchema
+})
+    .strict();
+export const batchCompletionStreamResponseSchema = z
+    .object({
+    type: z.literal('batchCompletionStream'),
+    done: z.boolean().optional(),
+    ids: z.array(z.string()).optional(),
+    events: z.array(batchCompletionEventSchema),
+    // Batch-level stats reported once on the terminal (`done`) frame. The
+    // addon aggregates decode metrics across the whole batch (e.g.
+    // `avgConcurrentSeq`, total prompt/generated tokens) — it does NOT
+    // break them down per prompt — so they belong on the run, not on each
+    // prompt's `final.stats`.
+    stats: completionStatsSchema.optional()
+})
+    .strict();

package/dist/schemas/bci-config.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const bciConfigSchema: z.ZodObject<{
     whisperConfig: z.ZodOptional<z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;

package/dist/schemas/bci-config.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { modelSrcInputSchema } from "./model-src-utils.js";
+import { z } from 'zod';
+import { modelSrcInputSchema } from './model-src-utils.js';
 // === BCI (whisper.cpp) engine config ===
 //
 // Mirrors `BCIWhispercppConfig` from `@qvac/bci-whispercpp`. Unlike the
@@ -25,14 +25,14 @@ const bciWhisperConfigSchema = z
     print_timestamps: z.boolean().optional(),
     detect_language: z.boolean().optional(),
     greedy_best_of: z.number().int().optional(),
-    beam_search_beam_size: z.number().int().optional(),
+    beam_search_beam_size: z.number().int().optional()
 })
     .optional();
 const bciSessionConfigSchema = z
     .object({
     // Session day index used to select day-specific projection matrices.
     // `-1` enables mel passthrough (parity testing only).
-    day_idx: z.number().int().optional(),
+    day_idx: z.number().int().optional()
 })
     .optional();
 const bciContextParamsSchema = z
@@ -40,12 +40,12 @@ const bciContextParamsSchema = z
     model: z.string().optional(),
     use_gpu: z.boolean().optional(),
     flash_attn: z.boolean().optional(),
-    gpu_device: z.number().optional(),
+    gpu_device: z.number().optional()
 })
     .optional();
 const bciMiscConfigSchema = z
     .object({
-    caption_enabled: z.boolean().optional(),
+    caption_enabled: z.boolean().optional()
 })
     .optional();
 export const bciConfigSchema = z.object({
@@ -54,5 +54,5 @@ export const bciConfigSchema = z.object({
     contextParams: bciContextParamsSchema,
     miscConfig: bciMiscConfigSchema,
     backendsDir: z.string().optional(),
-    embedderModelSrc: modelSrcInputSchema.optional(),
+    embedderModelSrc: modelSrcInputSchema.optional()
 });

package/dist/schemas/bci.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { type TranscribeSegment } from "./transcription";
+import { z } from 'zod';
+import { type TranscribeSegment } from './transcription';
 export declare const neuralInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"base64">;
     value: z.ZodString;
@@ -152,7 +152,7 @@ export type BciTranscribeStreamClientParams = {
     metadata?: boolean;
     windowTimesteps?: number;
     hopTimesteps?: number;
-    emit?: "delta" | "full";
+    emit?: 'delta' | 'full';
 };
 export interface BciTranscribeStreamSession {
     /**