@qvac/sdk 0.14.1 → 0.16.0

package/dist/schemas/common.js

@@ -1,38 +1,41 @@
-import { z } from "zod";
-import { perCallProfilingSchema } from "./profiling.js";
-import { heartbeatRequestSchema, heartbeatResponseSchema } from "./heartbeat.js";
-import { completionStreamRequestSchema, completionStreamResponseSchema, } from "./completion-stream.js";
-import { loadModelRequestSchema, loadModelResponseSchema, modelProgressUpdateSchema, } from "./load-model.js";
-import { downloadAssetRequestSchema, downloadAssetResponseSchema, } from "./download-asset.js";
-import { unloadModelRequestSchema, unloadModelResponseSchema, } from "./unload-model.js";
-import { transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema, } from "./transcription.js";
-import { bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema, } from "./bci.js";
-import { embedRequestSchema, embedResponseSchema } from "./embed.js";
-import { cancelRequestSchema, cancelResponseSchema } from "./cancel.js";
-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, 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, videoStreamRequestSchema, videoStreamResponseSchema, upscaleStreamRequestSchema, upscaleStreamResponseSchema, } from "./sdcpp-config.js";
-import { finetuneRequestSchema, finetuneResponseSchema, finetuneProgressResponseSchema, } from "./finetune.js";
-import { pluginInvokeRequestSchema, pluginInvokeResponseSchema, pluginInvokeStreamRequestSchema, pluginInvokeStreamResponseSchema, } from "./plugin.js";
-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";
-import { classifyRequestSchema, classifyResponseSchema, } from "./classification.js";
+import { z } from 'zod';
+import { perCallProfilingSchema } from './profiling.js';
+import { heartbeatRequestSchema, heartbeatResponseSchema } from './heartbeat.js';
+import { completionOrchestrateRequestSchema, completionOrchestrateResponseSchema, completionStreamRequestSchema, completionStreamResponseSchema } from './completion-stream.js';
+import { batchCompletionStreamRequestSchema, batchCompletionStreamResponseSchema } from './batch-completion-stream.js';
+import { loadModelRequestSchema, loadModelResponseSchema, modelProgressUpdateSchema } from './load-model.js';
+import { downloadAssetRequestSchema, downloadAssetResponseSchema } from './download-asset.js';
+import { unloadModelRequestSchema, unloadModelResponseSchema } from './unload-model.js';
+import { transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema } from './transcription.js';
+import { bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema } from './bci.js';
+import { embedRequestSchema, embedResponseSchema } from './embed.js';
+import { cancelRequestSchema, cancelResponseSchema } from './cancel.js';
+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, 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, videoStreamRequestSchema, videoStreamResponseSchema, upscaleStreamRequestSchema, upscaleStreamResponseSchema } from './sdcpp-config.js';
+import { finetuneRequestSchema, finetuneResponseSchema, finetuneProgressResponseSchema } from './finetune.js';
+import { pluginInvokeRequestSchema, pluginInvokeResponseSchema, pluginInvokeStreamRequestSchema, pluginInvokeStreamResponseSchema } from './plugin.js';
+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';
+import { classifyRequestSchema, classifyResponseSchema } from './classification.js';
 export const requestSchema = z.union([
     heartbeatRequestSchema,
     loadModelRequestSchema,
     downloadAssetRequestSchema,
     completionStreamRequestSchema,
+    completionOrchestrateRequestSchema,
+    batchCompletionStreamRequestSchema,
     unloadModelRequestSchema,
     transcribeRequestSchema,
     transcribeStreamRequestSchema,
@@ -63,13 +66,15 @@ export const requestSchema = z.union([
     suspendRequestSchema,
     resumeRequestSchema,
     stateRequestSchema,
-    classifyRequestSchema,
+    classifyRequestSchema
 ]);
-export const responseSchema = z.discriminatedUnion("type", [
+export const responseSchema = z.discriminatedUnion('type', [
     heartbeatResponseSchema,
     loadModelResponseSchema,
     downloadAssetResponseSchema,
     completionStreamResponseSchema,
+    completionOrchestrateResponseSchema,
+    batchCompletionStreamResponseSchema,
     unloadModelResponseSchema,
     modelProgressUpdateSchema,
     transcribeResponseSchema,
@@ -104,24 +109,24 @@ export const responseSchema = z.discriminatedUnion("type", [
     suspendResponseSchema,
     resumeResponseSchema,
     stateResponseSchema,
-    classifyResponseSchema,
+    classifyResponseSchema
 ]);
 export const rpcOptionsSchema = z.object({
     timeout: z
         .number()
         .min(100)
         .optional()
-        .describe("Per-call RPC timeout in milliseconds; overrides the SDK-level default for this request only."),
+        .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."),
+        .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."),
+        .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."),
+        .describe("Per-call profiler configuration; when present, overrides the SDK's global profiler settings for this request.")
 });

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

@@ -1,15 +1,16 @@
-import { z } from "zod";
-import { type Tool, type ToolCallWithCall } from "./tools";
-import type { ToolDialect } from "./completion-stream";
+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>;
     promptTokens: z.ZodOptional<z.ZodNumber>;
     generatedTokens: z.ZodOptional<z.ZodNumber>;
+    avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
     backendDevice: z.ZodOptional<z.ZodEnum<{
-        cpu: "cpu";
         gpu: "gpu";
+        cpu: "cpu";
     }>>;
 }, z.core.$strip>;
 export type CompletionStats = z.infer<typeof completionStatsSchema>;
@@ -61,9 +62,10 @@ export declare const statsEventSchema: z.ZodObject<{
         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<{
-            cpu: "cpu";
             gpu: "gpu";
+            cpu: "cpu";
         }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -141,9 +143,10 @@ export declare const completionEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         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<{
-            cpu: "cpu";
             gpu: "gpu";
+            cpu: "cpu";
         }>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -225,8 +228,8 @@ export type CompletionRun = {
     toolCalls: Promise<ToolCallWithCall[]>;
     stats: Promise<CompletionStats | undefined>;
 };
-export type ToolCallingCapability = "textParse" | "none";
-export type ThinkingFramingCapability = "thinkTags" | "none";
+export type ToolCallingCapability = 'textParse' | 'none';
+export type ThinkingFramingCapability = 'thinkTags' | 'none';
 export type PluginCapabilities = {
     toolCalling: ToolCallingCapability;
     thinkingFraming: ThinkingFramingCapability;

package/dist/schemas/completion-event.js

@@ -1,49 +1,50 @@
-import { z } from "zod";
-import { toolCallSchema, toolCallErrorSchema, } from "./tools.js";
+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(),
     promptTokens: z.number().optional(),
     generatedTokens: z.number().optional(),
-    backendDevice: z.enum(["cpu", "gpu"]).optional(),
+    avgConcurrentSeq: 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"),
+    type: z.literal('contentDelta'),
     seq: seqSchema,
-    text: z.string(),
+    text: z.string()
 });
 export const rawDeltaEventSchema = z.object({
-    type: z.literal("rawDelta"),
+    type: z.literal('rawDelta'),
     seq: seqSchema,
-    text: z.string(),
+    text: z.string()
 });
 export const thinkingDeltaEventSchema = z.object({
-    type: z.literal("thinkingDelta"),
+    type: z.literal('thinkingDelta'),
     seq: seqSchema,
-    text: z.string(),
+    text: z.string()
 });
 export const toolCallEventSchema = z.object({
-    type: z.literal("toolCall"),
+    type: z.literal('toolCall'),
     seq: seqSchema,
-    call: toolCallSchema,
+    call: toolCallSchema
 });
 export const toolErrorEventSchema = z.object({
-    type: z.literal("toolError"),
+    type: z.literal('toolError'),
     seq: seqSchema,
-    error: toolCallErrorSchema,
+    error: toolCallErrorSchema
 });
 export const statsEventSchema = z.object({
-    type: z.literal("completionStats"),
+    type: z.literal('completionStats'),
     seq: seqSchema,
-    stats: completionStatsSchema,
+    stats: completionStatsSchema
 });
 export const completionErrorSchema = z.object({
-    message: z.string(),
+    message: z.string()
 });
 const rawOutputSchema = z.object({
-    fullText: z.string(),
+    fullText: z.string()
 });
 // `"cancelled"` is a clean termination, not a mid-stream failure: the
 // stream ended on purpose because the request was aborted, just not at
@@ -55,22 +56,22 @@ const rawOutputSchema = z.object({
 // client-side `CompletionRun` (`final` / `text` / `toolCalls` / `stats`)
 // reject with `InferenceCancelledError` carrying the partial state — see
 // `client/api/completion-stream.ts` for the rejection plumbing.
-const stopReasonEnum = z.enum(["eos", "length", "stopSequence", "cancelled"]);
+const stopReasonEnum = z.enum(['eos', 'length', 'stopSequence', 'cancelled']);
 const successDoneSchema = z
     .object({
-    type: z.literal("completionDone"),
+    type: z.literal('completionDone'),
     seq: seqSchema,
     stopReason: stopReasonEnum.optional(),
-    raw: rawOutputSchema.optional(),
+    raw: rawOutputSchema.optional()
 })
     .strict();
 const errorDoneSchema = z
     .object({
-    type: z.literal("completionDone"),
+    type: z.literal('completionDone'),
     seq: seqSchema,
-    stopReason: z.literal("error"),
+    stopReason: z.literal('error'),
     error: completionErrorSchema,
-    raw: rawOutputSchema.optional(),
+    raw: rawOutputSchema.optional()
 })
     .strict();
 export const doneEventSchema = z.union([errorDoneSchema, successDoneSchema]);
@@ -82,9 +83,9 @@ export const completionEventSchema = z.union([
     toolErrorEventSchema,
     statsEventSchema,
     errorDoneSchema,
-    successDoneSchema,
+    successDoneSchema
 ]);
 export const DEFAULT_PLUGIN_CAPABILITIES = {
-    toolCalling: "none",
-    thinkingFraming: "none",
+    toolCalling: 'none',
+    thinkingFraming: 'none'
 };

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

@@ -1,5 +1,5 @@
-import { z } from "zod";
-export { completionStatsSchema, type CompletionStats, } from "./completion-event";
+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.
@@ -84,7 +84,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
                     integer: "integer";
                 }>;
                 description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
             }, z.core.$strip>>;
             required: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
@@ -153,7 +153,7 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
                     integer: "integer";
                 }>;
                 description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
             }, z.core.$strip>>;
             required: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
@@ -243,9 +243,10 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
             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<{
-                cpu: "cpu";
                 gpu: "gpu";
+                cpu: "cpu";
             }>>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{
@@ -272,6 +273,187 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strict>]>>;
 }, z.core.$strict>;
+export declare const completionOrchestrateRequestSchema: z.ZodObject<{
+    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>>;
+    modelId: z.ZodString;
+    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.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+            }, z.core.$strip>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    stream: z.ZodBoolean;
+    kvCache: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    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>>;
+    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";
+    }>>;
+    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">>;
+    requestId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"completionOrchestrate">;
+    maxToolTurns: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Downstream frame of the orchestrated completion duplex stream. Exactly one
+ * payload field is set per frame:
+ *
+ * - `events` — pass-through of the inner completion turn's events (with
+ *   `turn` identifying which generation pass they belong to).
+ * - `toolCallback` — the worker is asking the CLIENT to run a tool. The
+ *   client executes its registered handler and writes a JSON line
+ *   (`toolCallbackResultSchema`) up the request stream. The worker blocks
+ *   this run (not the socket) until the matching `callId` arrives.
+ * - `done` — terminal frame; the loop ended (final answer produced, error,
+ *   cancellation, or the `maxToolTurns` cap).
+ *
+ * Only a LOCAL worker may emit `toolCallback`: tool handlers execute code on
+ * the client machine, so a remote delegate streaming through this shape must
+ * never trigger them.
+ */
+export declare const completionOrchestrateResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"completionOrchestrate">;
+    turn: z.ZodOptional<z.ZodNumber>;
+    events: z.ZodOptional<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;
+            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>]>>>;
+    toolCallback: z.ZodOptional<z.ZodObject<{
+        callId: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    stopReason: z.ZodOptional<z.ZodLiteral<"maxToolTurns">>;
+}, z.core.$strict>;
+/**
+ * Upstream JSON line the client writes after running a tool callback.
+ * Newline-delimited on the duplex request stream, after the initial request
+ * payload. `error` reports a handler failure; the worker forwards it to the
+ * model as the tool result so the loop can recover or finish.
+ */
+export declare const toolCallbackResultSchema: z.ZodObject<{
+    callId: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export type GenerationParams = z.infer<typeof generationParamsSchema>;
 export type CompletionParams = z.infer<typeof completionParamsSchema>;
 export type ToolDialect = z.infer<typeof toolDialectSchema>;
@@ -279,5 +461,8 @@ 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 CompletionOrchestrateRequest = z.infer<typeof completionOrchestrateRequestSchema>;
+export type CompletionOrchestrateResponse = z.infer<typeof completionOrchestrateResponseSchema>;
+export type ToolCallbackResult = z.infer<typeof toolCallbackResultSchema>;
 export type Attachment = z.infer<typeof attachmentSchema>;
 //# sourceMappingURL=completion-stream.d.ts.map