@qvac/sdk 0.9.2 → 0.10.1

package/dist/schemas/common.js

@@ -12,11 +12,12 @@ import { provideRequestSchema, provideResponseSchema } from "./provide.js";
 import { stopProvideRequestSchema, stopProvideResponseSchema, } from "./stop-provide.js";
 import { translateRequestSchema, translateResponseSchema } from "./translate.js";
 import { loggingStreamRequestSchema, loggingStreamResponseSchema, } from "./logging-stream.js";
-import { ttsRequestSchema, ttsResponseSchema } from "./text-to-speech.js";
+import { ttsRequestSchema, ttsResponseSchema, textToSpeechStreamRequestSchema, textToSpeechStreamResponseSchema, } from "./text-to-speech.js";
 import { errorResponseSchema } from "./error.js";
 import { ragRequestSchema, ragResponseSchema, ragProgressUpdateSchema, } from "./rag.js";
 import { deleteCacheRequestSchema, deleteCacheResponseSchema, } from "./delete-cache.js";
 import { getModelInfoRequestSchema, getModelInfoResponseSchema, } from "./get-model-info.js";
+import { getLoadedModelInfoRequestSchema, getLoadedModelInfoResponseSchema, } from "./get-loaded-model-info.js";
 import { ocrStreamRequestSchema, ocrStreamResponseSchema } from "./ocr.js";
 import { diffusionStreamRequestSchema, diffusionStreamResponseSchema, } from "./sdcpp-config.js";
 import { finetuneRequestSchema, finetuneResponseSchema, finetuneProgressResponseSchema, } from "./finetune.js";
@@ -24,6 +25,7 @@ import { pluginInvokeRequestSchema, pluginInvokeResponseSchema, pluginInvokeStre
 import { modelRegistryListRequestSchema, modelRegistryListResponseSchema, modelRegistrySearchRequestSchema, modelRegistrySearchResponseSchema, modelRegistryGetModelRequestSchema, modelRegistryGetModelResponseSchema, } from "./registry.js";
 import { suspendRequestSchema, suspendResponseSchema } from "./suspend.js";
 import { resumeRequestSchema, resumeResponseSchema } from "./resume.js";
+import { stateRequestSchema, stateResponseSchema } from "./state.js";
 export const requestSchema = z.union([
     heartbeatRequestSchema,
     loadModelRequestSchema,
@@ -36,12 +38,14 @@ export const requestSchema = z.union([
     embedRequestSchema,
     translateRequestSchema,
     ttsRequestSchema,
+    textToSpeechStreamRequestSchema,
     cancelRequestSchema,
     provideRequestSchema,
     stopProvideRequestSchema,
     ragRequestSchema,
     deleteCacheRequestSchema,
     getModelInfoRequestSchema,
+    getLoadedModelInfoRequestSchema,
     ocrStreamRequestSchema,
     diffusionStreamRequestSchema,
     finetuneRequestSchema,
@@ -52,6 +56,7 @@ export const requestSchema = z.union([
     modelRegistryGetModelRequestSchema,
     suspendRequestSchema,
     resumeRequestSchema,
+    stateRequestSchema,
 ]);
 export const responseSchema = z.discriminatedUnion("type", [
     heartbeatResponseSchema,
@@ -66,6 +71,7 @@ export const responseSchema = z.discriminatedUnion("type", [
     embedResponseSchema,
     translateResponseSchema,
     ttsResponseSchema,
+    textToSpeechStreamResponseSchema,
     cancelResponseSchema,
     provideResponseSchema,
     stopProvideResponseSchema,
@@ -74,6 +80,7 @@ export const responseSchema = z.discriminatedUnion("type", [
     ragProgressUpdateSchema,
     deleteCacheResponseSchema,
     getModelInfoResponseSchema,
+    getLoadedModelInfoResponseSchema,
     ocrStreamResponseSchema,
     diffusionStreamResponseSchema,
     finetuneResponseSchema,
@@ -85,10 +92,24 @@ export const responseSchema = z.discriminatedUnion("type", [
     modelRegistryGetModelResponseSchema,
     suspendResponseSchema,
     resumeResponseSchema,
+    stateResponseSchema,
 ]);
 export const rpcOptionsSchema = z.object({
-    timeout: z.number().min(100).optional(),
-    healthCheckTimeout: z.number().min(100).optional(),
-    forceNewConnection: z.boolean().optional(),
-    profiling: perCallProfilingSchema.optional(),
+    timeout: z
+        .number()
+        .min(100)
+        .optional()
+        .describe("Per-call RPC timeout in milliseconds; overrides the SDK-level default for this request only."),
+    healthCheckTimeout: z
+        .number()
+        .min(100)
+        .optional()
+        .describe("Timeout in milliseconds for the health-check probe that precedes the RPC call."),
+    forceNewConnection: z
+        .boolean()
+        .optional()
+        .describe("When `true`, skip any cached RPC connection and open a fresh one for this call."),
+    profiling: perCallProfilingSchema
+        .optional()
+        .describe("Per-call profiler configuration; when present, overrides the SDK's global profiler settings for this request."),
 });

package/dist/schemas/completion-event.d.ts

@@ -0,0 +1,225 @@
+import { z } from "zod";
+import { type Tool, type ToolCallWithCall } from "./tools";
+import type { ToolDialect } from "./completion-stream";
+export declare const completionStatsSchema: z.ZodObject<{
+    timeToFirstToken: z.ZodOptional<z.ZodNumber>;
+    tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+    cacheTokens: z.ZodOptional<z.ZodNumber>;
+    generatedTokens: z.ZodOptional<z.ZodNumber>;
+    backendDevice: z.ZodOptional<z.ZodEnum<{
+        cpu: "cpu";
+        gpu: "gpu";
+    }>>;
+}, z.core.$strip>;
+export type CompletionStats = z.infer<typeof completionStatsSchema>;
+export declare const seqSchema: z.ZodNumber;
+export declare const contentDeltaEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"contentDelta">;
+    seq: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const rawDeltaEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"rawDelta">;
+    seq: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const thinkingDeltaEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"thinkingDelta">;
+    seq: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const toolCallEventSchema: 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>;
+export declare const toolErrorEventSchema: 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>;
+export declare const statsEventSchema: 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>;
+        generatedTokens: z.ZodOptional<z.ZodNumber>;
+        backendDevice: z.ZodOptional<z.ZodEnum<{
+            cpu: "cpu";
+            gpu: "gpu";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const completionErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+}, z.core.$strip>;
+declare const stopReasonEnum: z.ZodEnum<{
+    eos: "eos";
+    length: "length";
+    stopSequence: "stopSequence";
+}>;
+export declare const doneEventSchema: z.ZodUnion<readonly [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<{
+        eos: "eos";
+        length: "length";
+        stopSequence: "stopSequence";
+    }>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        fullText: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>]>;
+export declare const completionEventSchema: 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>;
+        generatedTokens: z.ZodOptional<z.ZodNumber>;
+        backendDevice: z.ZodOptional<z.ZodEnum<{
+            cpu: "cpu";
+            gpu: "gpu";
+        }>>;
+    }, 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<{
+        eos: "eos";
+        length: "length";
+        stopSequence: "stopSequence";
+    }>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        fullText: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strict>]>;
+export type ContentDeltaEvent = z.infer<typeof contentDeltaEventSchema>;
+export type RawDeltaEvent = z.infer<typeof rawDeltaEventSchema>;
+export type ThinkingDeltaEvent = z.infer<typeof thinkingDeltaEventSchema>;
+export type ToolCallEvent = z.infer<typeof toolCallEventSchema>;
+export type ToolErrorEvent = z.infer<typeof toolErrorEventSchema>;
+export type StatsEvent = z.infer<typeof statsEventSchema>;
+export type CompletionError = z.infer<typeof completionErrorSchema>;
+export type DoneEvent = z.infer<typeof doneEventSchema>;
+export type CompletionEvent = z.infer<typeof completionEventSchema>;
+export type StopReason = z.infer<typeof stopReasonEnum>;
+export type CompletionFinal = {
+    contentText: string;
+    thinkingText?: string;
+    toolCalls: ToolCallWithCall[];
+    stats?: CompletionStats;
+    raw: {
+        fullText: string;
+    };
+    /**
+     * Canonical assistant text to push back into `history` for the next turn
+     * when using `kvCache: true` (auto-cache). Equals the assistant content
+     * the SDK persisted to the cache key on this turn, so re-using it
+     * verbatim guarantees a cache hit on the next call.
+     *
+     * Derived from `raw.fullText` (or `contentText` if the addon didn't
+     * emit raw text) by stripping `<think>` reasoning blocks and trimming
+     * surrounding whitespace — see `normalizeAssistantCacheContent`.
+     *
+     * Tool-call turns currently can't be auto-cached, so this
+     * field is omitted when `toolCalls.length > 0`.
+     */
+    cacheableAssistantContent?: string;
+};
+export type CompletionRun = {
+    /** Ordered stream of typed completion events — the canonical consumption API. */
+    events: AsyncIterable<CompletionEvent>;
+    /** Resolves when the stream ends with aggregated content, thinking, tool calls, stats, and raw output. */
+    final: Promise<CompletionFinal>;
+    tokenStream: AsyncGenerator<string>;
+    toolCallStream: AsyncGenerator<ToolCallEvent>;
+    text: Promise<string>;
+    toolCalls: Promise<ToolCallWithCall[]>;
+    stats: Promise<CompletionStats | undefined>;
+};
+export type ToolCallingCapability = "textParse" | "none";
+export type ThinkingFramingCapability = "thinkTags" | "none";
+export type PluginCapabilities = {
+    toolCalling: ToolCallingCapability;
+    thinkingFraming: ThinkingFramingCapability;
+};
+export declare const DEFAULT_PLUGIN_CAPABILITIES: PluginCapabilities;
+export type NormalizerConfig = {
+    capabilities: PluginCapabilities;
+    tools: Tool[];
+    captureThinking: boolean;
+    emitRawDeltas: boolean;
+    toolDialect?: ToolDialect;
+};
+export {};
+//# sourceMappingURL=completion-event.d.ts.map

package/dist/schemas/completion-event.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+import { toolCallSchema, toolCallErrorSchema, } from "./tools.js";
+export const completionStatsSchema = z.object({
+    timeToFirstToken: z.number().optional(),
+    tokensPerSecond: z.number().optional(),
+    cacheTokens: z.number().optional(),
+    generatedTokens: z.number().optional(),
+    backendDevice: z.enum(["cpu", "gpu"]).optional(),
+});
+export const seqSchema = z.number().int().nonnegative();
+export const contentDeltaEventSchema = z.object({
+    type: z.literal("contentDelta"),
+    seq: seqSchema,
+    text: z.string(),
+});
+export const rawDeltaEventSchema = z.object({
+    type: z.literal("rawDelta"),
+    seq: seqSchema,
+    text: z.string(),
+});
+export const thinkingDeltaEventSchema = z.object({
+    type: z.literal("thinkingDelta"),
+    seq: seqSchema,
+    text: z.string(),
+});
+export const toolCallEventSchema = z.object({
+    type: z.literal("toolCall"),
+    seq: seqSchema,
+    call: toolCallSchema,
+});
+export const toolErrorEventSchema = z.object({
+    type: z.literal("toolError"),
+    seq: seqSchema,
+    error: toolCallErrorSchema,
+});
+export const statsEventSchema = z.object({
+    type: z.literal("completionStats"),
+    seq: seqSchema,
+    stats: completionStatsSchema,
+});
+export const completionErrorSchema = z.object({
+    message: z.string(),
+});
+const rawOutputSchema = z.object({
+    fullText: z.string(),
+});
+const stopReasonEnum = z.enum(["eos", "length", "stopSequence"]);
+const successDoneSchema = z
+    .object({
+    type: z.literal("completionDone"),
+    seq: seqSchema,
+    stopReason: stopReasonEnum.optional(),
+    raw: rawOutputSchema.optional(),
+})
+    .strict();
+const errorDoneSchema = z
+    .object({
+    type: z.literal("completionDone"),
+    seq: seqSchema,
+    stopReason: z.literal("error"),
+    error: completionErrorSchema,
+    raw: rawOutputSchema.optional(),
+})
+    .strict();
+export const doneEventSchema = z.union([errorDoneSchema, successDoneSchema]);
+export const completionEventSchema = z.union([
+    contentDeltaEventSchema,
+    rawDeltaEventSchema,
+    thinkingDeltaEventSchema,
+    toolCallEventSchema,
+    toolErrorEventSchema,
+    statsEventSchema,
+    errorDoneSchema,
+    successDoneSchema,
+]);
+export const DEFAULT_PLUGIN_CAPABILITIES = {
+    toolCalling: "none",
+    thinkingFraming: "none",
+};

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

@@ -1,4 +1,21 @@
 import { z } from "zod";
+export { completionStatsSchema, type CompletionStats } from "./completion-event";
+/**
+ * Tool-call output dialect. Auto-detected from the model name; pass via
+ * `completion({ toolDialect })` to override.
+ *
+ * Expected raw model output per dialect:
+ * - `"hermes"`:   `<tool_call>{"name":"get_weather","arguments":{"city":"Tokyo"}}</tool_call>`
+ * - `"pythonic"`: `[get_weather(city="Tokyo")]` (optionally `<|tool_call_start|>...<|tool_call_end|>`-wrapped)
+ * - `"json"`:     `{"name":"get_weather","arguments":{"city":"Tokyo"}}` or `{"tool_calls":[{"name":"...","arguments":{...}}]}`
+ * - `"harmony"`:  `<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"city":"Tokyo"}<|call|>`
+ */
+export declare const toolDialectSchema: z.ZodEnum<{
+    hermes: "hermes";
+    pythonic: "pythonic";
+    json: "json";
+    harmony: "harmony";
+}>;
 export declare const attachmentSchema: z.ZodObject<{
     path: z.ZodString;
 }, z.core.$strip>;
@@ -12,6 +29,19 @@ export declare const generationParamsSchema: z.ZodObject<{
     presence_penalty: z.ZodOptional<z.ZodNumber>;
     repeat_penalty: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+export declare const responseFormatSchema: 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">;
 export declare const completionParamsSchema: z.ZodObject<{
     history: z.ZodArray<z.ZodObject<{
         role: z.ZodString;
@@ -65,6 +95,27 @@ export declare const completionClientParamsSchema: z.ZodObject<{
         presence_penalty: z.ZodOptional<z.ZodNumber>;
         repeat_penalty: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    captureThinking: z.ZodOptional<z.ZodBoolean>;
+    emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
+    }>>;
+    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">>;
 }, z.core.$strip>;
 export declare const completionStreamRequestSchema: z.ZodObject<{
     history: z.ZodArray<z.ZodObject<{
@@ -108,32 +159,47 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
         presence_penalty: z.ZodOptional<z.ZodNumber>;
         repeat_penalty: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
-    type: z.ZodLiteral<"completionStream">;
-}, z.core.$strip>;
-export declare const completionStatsSchema: z.ZodObject<{
-    timeToFirstToken: z.ZodOptional<z.ZodNumber>;
-    tokensPerSecond: z.ZodOptional<z.ZodNumber>;
-    cacheTokens: z.ZodOptional<z.ZodNumber>;
-    backendDevice: z.ZodOptional<z.ZodEnum<{
-        cpu: "cpu";
-        gpu: "gpu";
+    captureThinking: z.ZodOptional<z.ZodBoolean>;
+    emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
     }>>;
+    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">>;
+    type: z.ZodLiteral<"completionStream">;
 }, z.core.$strip>;
 export declare const completionStreamResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"completionStream">;
-    token: z.ZodString;
     done: z.ZodOptional<z.ZodBoolean>;
-    stats: z.ZodOptional<z.ZodObject<{
-        timeToFirstToken: z.ZodOptional<z.ZodNumber>;
-        tokensPerSecond: z.ZodOptional<z.ZodNumber>;
-        cacheTokens: z.ZodOptional<z.ZodNumber>;
-        backendDevice: z.ZodOptional<z.ZodEnum<{
-            cpu: "cpu";
-            gpu: "gpu";
-        }>>;
-    }, z.core.$strip>>;
-    toolCallEvent: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+    events: z.ZodArray<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;
@@ -141,7 +207,8 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
             raw: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"toolCallError">;
+        type: z.ZodLiteral<"toolError">;
+        seq: z.ZodNumber;
         error: z.ZodObject<{
             code: z.ZodEnum<{
                 PARSE_ERROR: "PARSE_ERROR";
@@ -151,20 +218,48 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
             message: z.ZodString;
             raw: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
-    }, z.core.$strip>]>>;
-    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        raw: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    error: 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>;
+            generatedTokens: z.ZodOptional<z.ZodNumber>;
+            backendDevice: z.ZodOptional<z.ZodEnum<{
+                cpu: "cpu";
+                gpu: "gpu";
+            }>>;
+        }, 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<{
+            eos: "eos";
+            length: "length";
+            stopSequence: "stopSequence";
+        }>>;
+        raw: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
 export type GenerationParams = z.infer<typeof generationParamsSchema>;
 export type CompletionParams = z.infer<typeof completionParamsSchema>;
+export type ToolDialect = z.infer<typeof toolDialectSchema>;
+export type ResponseFormat = z.infer<typeof responseFormatSchema>;
 export type CompletionClientParams = z.input<typeof completionClientParamsSchema>;
 export type CompletionStreamRequest = z.infer<typeof completionStreamRequestSchema>;
 export type CompletionStreamResponse = z.infer<typeof completionStreamResponseSchema>;
 export type Attachment = z.infer<typeof attachmentSchema>;
-export type CompletionStats = z.infer<typeof completionStatsSchema>;
 //# sourceMappingURL=completion-stream.d.ts.map