@henjicc/ai-sdk 0.2.8

package/dist/llm/modelStep.d.ts

@@ -0,0 +1,327 @@
+import { z } from 'zod';
+export declare const modelStepMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    role: z.ZodLiteral<"system">;
+    content: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"user">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+}, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"assistant">;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+}, z.core.$strip>, z.ZodObject<{
+    role: z.ZodLiteral<"tool">;
+    content: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>], "role">;
+export type ModelStepMessage = z.infer<typeof modelStepMessageSchema>;
+export declare const modelStepCapabilitiesSchema: z.ZodObject<{
+    image: z.ZodBoolean;
+    video: z.ZodBoolean;
+    audio: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodBoolean>;
+    streaming: z.ZodBoolean;
+    toolCall: z.ZodBoolean;
+    parallelTools: z.ZodBoolean;
+    structuredOutputMode: z.ZodEnum<{
+        none: "none";
+        json: "json";
+        schema: "schema";
+    }>;
+    reasoning: z.ZodBoolean;
+    sampling: z.ZodBoolean;
+    usage: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModelStepCapabilities = z.infer<typeof modelStepCapabilitiesSchema>;
+export declare const modelInputModalitySchema: z.ZodEnum<{
+    image: "image";
+    video: "video";
+    audio: "audio";
+    file: "file";
+}>;
+export type ModelInputModality = z.infer<typeof modelInputModalitySchema>;
+/** 只记录输入包含的模态，不读取或复制媒体内容。 */
+export declare function detectModelStepInputModalities(messages: ModelStepMessage[]): ModelInputModality[];
+export declare function assertModelStepInputCapabilities(input: Pick<ModelStepInput, 'messages' | 'capabilities'>): void;
+export declare const modelStepToolSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ModelStepTool = z.infer<typeof modelStepToolSchema>;
+/**
+ * Agent 模型步骤的调试元数据。它只描述上下文构建结果，不改变供应商请求语义；
+ * 普通 LLM 调用可以省略该字段。
+ */
+export declare const modelStepTraceMetadataSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        fallback: "fallback";
+        router: "router";
+        primary: "primary";
+        summarizer: "summarizer";
+        observer: "observer";
+        other: "other";
+    }>;
+    inputModalities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        image: "image";
+        video: "video";
+        audio: "audio";
+        file: "file";
+    }>>>;
+    turn: z.ZodOptional<z.ZodNumber>;
+    snapshotRevision: z.ZodOptional<z.ZodNumber>;
+    contextWindowBudget: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    estimatedTokens: z.ZodOptional<z.ZodNumber>;
+    compacted: z.ZodOptional<z.ZodBoolean>;
+    beforeCompactionTokens: z.ZodOptional<z.ZodNumber>;
+    retainedLayers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    droppedLayers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    layerReports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        included: z.ZodBoolean;
+        estimatedTokens: z.ZodNumber;
+        truncated: z.ZodBoolean;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    activeToolNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ModelStepTraceMetadata = z.infer<typeof modelStepTraceMetadataSchema>;
+export declare const modelStepInputSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    runId: z.ZodString;
+    stepId: z.ZodString;
+    providerId: z.ZodString;
+    providerFamilyId: z.ZodOptional<z.ZodString>;
+    endpointProfile: z.ZodOptional<z.ZodString>;
+    credentialId: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodString;
+    apiProtocol: z.ZodOptional<z.ZodEnum<{
+        "openai-compatible": "openai-compatible";
+        "openai-responses": "openai-responses";
+    }>>;
+    adapter: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    system: z.ZodOptional<z.ZodString>;
+    messages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        role: z.ZodLiteral<"system">;
+        content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"assistant">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"tool">;
+        content: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>], "role">>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        strict: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    output: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"text">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"object">;
+        schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "mode">>;
+    capabilities: z.ZodObject<{
+        image: z.ZodBoolean;
+        video: z.ZodBoolean;
+        audio: z.ZodBoolean;
+        file: z.ZodOptional<z.ZodBoolean>;
+        streaming: z.ZodBoolean;
+        toolCall: z.ZodBoolean;
+        parallelTools: z.ZodBoolean;
+        structuredOutputMode: z.ZodEnum<{
+            none: "none";
+            json: "json";
+            schema: "schema";
+        }>;
+        reasoning: z.ZodBoolean;
+        sampling: z.ZodBoolean;
+        usage: z.ZodBoolean;
+    }, z.core.$strip>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        effort: z.ZodEnum<{
+            max: "max";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>;
+    }, z.core.$strip>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    pricing: z.ZodOptional<z.ZodObject<{
+        currency: z.ZodLiteral<"USD">;
+        inputPerMillionTokens: z.ZodNumber;
+        outputPerMillionTokens: z.ZodNumber;
+        cacheReadPerMillionTokens: z.ZodOptional<z.ZodNumber>;
+        cacheWritePerMillionTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    trace: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            fallback: "fallback";
+            router: "router";
+            primary: "primary";
+            summarizer: "summarizer";
+            observer: "observer";
+            other: "other";
+        }>;
+        inputModalities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            image: "image";
+            video: "video";
+            audio: "audio";
+            file: "file";
+        }>>>;
+        turn: z.ZodOptional<z.ZodNumber>;
+        snapshotRevision: z.ZodOptional<z.ZodNumber>;
+        contextWindowBudget: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        estimatedTokens: z.ZodOptional<z.ZodNumber>;
+        compacted: z.ZodOptional<z.ZodBoolean>;
+        beforeCompactionTokens: z.ZodOptional<z.ZodNumber>;
+        retainedLayers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        droppedLayers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        layerReports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            included: z.ZodBoolean;
+            estimatedTokens: z.ZodNumber;
+            truncated: z.ZodBoolean;
+            reason: z.ZodString;
+        }, z.core.$strict>>>;
+        activeToolNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type ModelStepInput = z.infer<typeof modelStepInputSchema>;
+export declare const modelStepToolCallSchema: z.ZodObject<{
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodUnknown;
+    dynamic: z.ZodBoolean;
+}, z.core.$strip>;
+export type ModelStepToolCall = z.infer<typeof modelStepToolCallSchema>;
+/**
+ * 与 AI SDK 6 的统一结束原因保持一致。未知结束原因在模型步骤边界即拒绝，
+ * 避免新供应商值未经运行时安全裁决便进入工具执行链。
+ */
+export declare const modelStepFinishReasonSchema: z.ZodEnum<{
+    error: "error";
+    length: "length";
+    stop: "stop";
+    other: "other";
+    "content-filter": "content-filter";
+    "tool-calls": "tool-calls";
+}>;
+export type ModelStepFinishReason = z.infer<typeof modelStepFinishReasonSchema>;
+export declare const modelStepUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNullable<z.ZodNumber>;
+    inputNoCacheTokens: z.ZodNullable<z.ZodNumber>;
+    cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+    cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+    outputTokens: z.ZodNullable<z.ZodNumber>;
+    textTokens: z.ZodNullable<z.ZodNumber>;
+    reasoningTokens: z.ZodNullable<z.ZodNumber>;
+    totalTokens: z.ZodNullable<z.ZodNumber>;
+    knownCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+export type ModelStepUsage = z.infer<typeof modelStepUsageSchema>;
+export declare const modelStepResultSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    runId: z.ZodString;
+    stepId: z.ZodString;
+    providerId: z.ZodString;
+    modelId: z.ZodString;
+    text: z.ZodString;
+    reasoningText: z.ZodString;
+    structuredOutput: z.ZodNullable<z.ZodUnknown>;
+    toolCalls: z.ZodArray<z.ZodObject<{
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        input: z.ZodUnknown;
+        dynamic: z.ZodBoolean;
+    }, z.core.$strip>>;
+    responseMessages: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        role: z.ZodLiteral<"system">;
+        content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"assistant">;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        role: z.ZodLiteral<"tool">;
+        content: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>], "role">>;
+    finishReason: z.ZodEnum<{
+        error: "error";
+        length: "length";
+        stop: "stop";
+        other: "other";
+        "content-filter": "content-filter";
+        "tool-calls": "tool-calls";
+    }>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        inputNoCacheTokens: z.ZodNullable<z.ZodNumber>;
+        cacheReadTokens: z.ZodNullable<z.ZodNumber>;
+        cacheWriteTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        textTokens: z.ZodNullable<z.ZodNumber>;
+        reasoningTokens: z.ZodNullable<z.ZodNumber>;
+        totalTokens: z.ZodNullable<z.ZodNumber>;
+        knownCostUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    providerMetadataSummary: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+    warnings: z.ZodArray<z.ZodString>;
+    elapsedMs: z.ZodNumber;
+}, z.core.$strip>;
+export type ModelStepResult = z.infer<typeof modelStepResultSchema>;
+export declare const modelStepEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"TextDelta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ReasoningDelta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ToolCall">;
+    toolCall: z.ZodObject<{
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+        input: z.ZodUnknown;
+        dynamic: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"Retrying">;
+    layer: z.ZodLiteral<"request">;
+    attempt: z.ZodNumber;
+    delayMs: z.ZodNumber;
+    category: z.ZodEnum<{
+        cancelled: "cancelled";
+        network: "network";
+        rate_limit: "rate_limit";
+        server: "server";
+        quota: "quota";
+        billing: "billing";
+        authentication: "authentication";
+        invalid_request: "invalid_request";
+        context_overflow: "context_overflow";
+        content_filter: "content_filter";
+        unknown: "unknown";
+    }>;
+    code: z.ZodString;
+}, z.core.$strip>], "type">;
+export type ModelStepEvent = z.infer<typeof modelStepEventSchema>;

package/dist/llm/modelStep.js

@@ -0,0 +1,200 @@
+import { z } from 'zod';
+import { modelProviderErrorCategorySchema } from '../runtime/errors.js';
+import { llmApiProtocolSchema } from './providerProtocol.js';
+const jsonRecordSchema = z.record(z.string(), z.unknown());
+const modelContentPartsSchema = z.array(jsonRecordSchema);
+export const modelStepMessageSchema = z.discriminatedUnion('role', [
+    z.object({ role: z.literal('system'), content: z.string() }),
+    z.object({ role: z.literal('user'), content: z.union([z.string(), modelContentPartsSchema]) }),
+    z.object({ role: z.literal('assistant'), content: z.union([z.string(), modelContentPartsSchema]) }),
+    z.object({ role: z.literal('tool'), content: modelContentPartsSchema }),
+]);
+export const modelStepCapabilitiesSchema = z.object({
+    image: z.boolean(),
+    video: z.boolean(),
+    audio: z.boolean(),
+    file: z.boolean().optional(),
+    streaming: z.boolean(),
+    toolCall: z.boolean(),
+    parallelTools: z.boolean(),
+    structuredOutputMode: z.enum(['none', 'json', 'schema']),
+    reasoning: z.boolean(),
+    sampling: z.boolean(),
+    usage: z.boolean(),
+});
+export const modelInputModalitySchema = z.enum(['image', 'video', 'audio', 'file']);
+function detectPartModality(part) {
+    if (part.type === 'image' || part.type === 'image_url')
+        return 'image';
+    if (part.type === 'video' || part.type === 'video_url')
+        return 'video';
+    if (part.type === 'input_audio')
+        return 'audio';
+    const mediaType = typeof part.mediaType === 'string' ? part.mediaType : '';
+    if (part.type === 'file' && mediaType.startsWith('image/'))
+        return 'image';
+    if (part.type === 'file' && mediaType.startsWith('video/'))
+        return 'video';
+    if (part.type === 'file' && mediaType.startsWith('audio/'))
+        return 'audio';
+    if (part.type === 'file')
+        return 'file';
+    return null;
+}
+/** 只记录输入包含的模态，不读取或复制媒体内容。 */
+export function detectModelStepInputModalities(messages) {
+    const modalities = new Set();
+    for (const message of messages) {
+        if (!Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            const modality = detectPartModality(part);
+            if (modality)
+                modalities.add(modality);
+        }
+    }
+    return [...modalities];
+}
+export function assertModelStepInputCapabilities(input) {
+    for (const modality of detectModelStepInputModalities(input.messages)) {
+        if (!input.capabilities[modality]) {
+            throw new Error(`[unsupported_input_modality] 当前模型未声明支持 ${modality} 输入`);
+        }
+    }
+}
+export const modelStepToolSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    inputSchema: jsonRecordSchema,
+    strict: z.boolean().optional(),
+});
+/**
+ * Agent 模型步骤的调试元数据。它只描述上下文构建结果，不改变供应商请求语义；
+ * 普通 LLM 调用可以省略该字段。
+ */
+export const modelStepTraceMetadataSchema = z.object({
+    kind: z.enum(['router', 'primary', 'summarizer', 'fallback', 'observer', 'other']),
+    inputModalities: z.array(modelInputModalitySchema).max(4).optional(),
+    turn: z.number().int().positive().optional(),
+    snapshotRevision: z.number().int().nonnegative().optional(),
+    contextWindowBudget: z.number().int().positive().optional(),
+    maxOutputTokens: z.number().int().positive().optional(),
+    estimatedTokens: z.number().int().nonnegative().optional(),
+    compacted: z.boolean().optional(),
+    beforeCompactionTokens: z.number().int().nonnegative().optional(),
+    retainedLayers: z.array(z.string().min(1).max(100)).max(32).optional(),
+    droppedLayers: z.array(z.string().min(1).max(100)).max(32).optional(),
+    layerReports: z.array(z.object({
+        id: z.string().min(1).max(100),
+        included: z.boolean(),
+        estimatedTokens: z.number().int().nonnegative(),
+        truncated: z.boolean(),
+        reason: z.string().max(500),
+    }).strict()).max(32).optional(),
+    activeToolNames: z.array(z.string().min(1).max(200)).max(64).optional(),
+}).strict();
+export const modelStepInputSchema = z.object({
+    requestId: z.string().min(1),
+    runId: z.string().min(1),
+    stepId: z.string().min(1),
+    providerId: z.string().min(1),
+    providerFamilyId: z.string().min(1).optional(),
+    endpointProfile: z.string().min(1).optional(),
+    credentialId: z.string().min(1).optional(),
+    modelId: z.string().min(1),
+    apiProtocol: llmApiProtocolSchema.optional(),
+    adapter: z.string().optional(),
+    baseUrl: z.string().optional(),
+    system: z.string().min(1).max(64 * 1024).optional(),
+    messages: z.array(modelStepMessageSchema).min(1),
+    tools: z.array(modelStepToolSchema).optional(),
+    output: z.discriminatedUnion('mode', [
+        z.object({ mode: z.literal('text') }),
+        z.object({
+            mode: z.literal('object'),
+            schema: jsonRecordSchema,
+            name: z.string().optional(),
+            description: z.string().optional(),
+        }),
+    ]).default({ mode: 'text' }),
+    capabilities: modelStepCapabilitiesSchema,
+    reasoning: z.object({
+        enabled: z.boolean(),
+        effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']),
+    }).optional(),
+    settings: z.object({
+        maxOutputTokens: z.number().int().positive().optional(),
+        temperature: z.number().finite().optional(),
+        topP: z.number().finite().optional(),
+        maxRetries: z.number().int().min(0).max(5).optional(),
+        timeoutMs: z.number().int().positive().optional(),
+    }).optional(),
+    providerOptions: z.record(z.string(), jsonRecordSchema).optional(),
+    pricing: z.object({
+        currency: z.literal('USD'),
+        inputPerMillionTokens: z.number().nonnegative(),
+        outputPerMillionTokens: z.number().nonnegative(),
+        cacheReadPerMillionTokens: z.number().nonnegative().optional(),
+        cacheWritePerMillionTokens: z.number().nonnegative().optional(),
+    }).strict().optional(),
+    trace: modelStepTraceMetadataSchema.optional(),
+});
+export const modelStepToolCallSchema = z.object({
+    toolCallId: z.string().min(1),
+    toolName: z.string().min(1),
+    input: z.unknown(),
+    dynamic: z.boolean(),
+});
+/**
+ * 与 AI SDK 6 的统一结束原因保持一致。未知结束原因在模型步骤边界即拒绝，
+ * 避免新供应商值未经运行时安全裁决便进入工具执行链。
+ */
+export const modelStepFinishReasonSchema = z.enum([
+    'stop',
+    'length',
+    'content-filter',
+    'tool-calls',
+    'error',
+    'other',
+]);
+export const modelStepUsageSchema = z.object({
+    inputTokens: z.number().int().nonnegative().nullable(),
+    inputNoCacheTokens: z.number().int().nonnegative().nullable(),
+    cacheReadTokens: z.number().int().nonnegative().nullable(),
+    cacheWriteTokens: z.number().int().nonnegative().nullable(),
+    outputTokens: z.number().int().nonnegative().nullable(),
+    textTokens: z.number().int().nonnegative().nullable(),
+    reasoningTokens: z.number().int().nonnegative().nullable(),
+    totalTokens: z.number().int().nonnegative().nullable(),
+    knownCostUsd: z.number().nonnegative().nullable().optional(),
+});
+export const modelStepResultSchema = z.object({
+    requestId: z.string().min(1),
+    runId: z.string().min(1),
+    stepId: z.string().min(1),
+    providerId: z.string().min(1),
+    modelId: z.string().min(1),
+    text: z.string(),
+    reasoningText: z.string(),
+    structuredOutput: z.unknown().nullable(),
+    toolCalls: z.array(modelStepToolCallSchema),
+    responseMessages: z.array(modelStepMessageSchema),
+    finishReason: modelStepFinishReasonSchema,
+    usage: modelStepUsageSchema,
+    providerMetadataSummary: z.record(z.string(), z.array(z.string())),
+    warnings: z.array(z.string()),
+    elapsedMs: z.number().int().nonnegative(),
+});
+export const modelStepEventSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('TextDelta'), text: z.string() }),
+    z.object({ type: z.literal('ReasoningDelta'), text: z.string() }),
+    z.object({ type: z.literal('ToolCall'), toolCall: modelStepToolCallSchema }),
+    z.object({
+        type: z.literal('Retrying'),
+        layer: z.literal('request'),
+        attempt: z.number().int().positive(),
+        delayMs: z.number().int().nonnegative(),
+        category: modelProviderErrorCategorySchema,
+        code: z.string().min(1),
+    }),
+]);

package/dist/llm/modules/client.d.ts

@@ -0,0 +1,2 @@
+import type { CreateLlmModuleClientConfig, LlmModuleClient } from './types.js';
+export declare function createLlmModuleClient(config: CreateLlmModuleClientConfig): LlmModuleClient;