@bowenqt/qiniu-ai-sdk 0.14.0 → 0.16.0

package/dist/ai/stream-object.mjs

@@ -0,0 +1,347 @@
+/**
+ * streamObject - Stream structured output with incremental parsing.
+ * Bypasses predict-node to enable streaming with JSON schema.
+ *
+ * @example
+ * ```typescript
+ * import { streamObject } from '@bowenqt/qiniu-ai-sdk';
+ * import { z } from 'zod';
+ *
+ * const { partialObjectStream, object } = await streamObject({
+ *     client,
+ *     model: 'gemini-2.5-flash',
+ *     schema: z.object({
+ *         title: z.string(),
+ *         chapters: z.array(z.object({
+ *             title: z.string(),
+ *             content: z.string(),
+ *         })),
+ *     }),
+ *     prompt: 'Generate a book outline about AI',
+ * });
+ *
+ * // Stream partial objects
+ * for await (const partial of partialObjectStream) {
+ *     console.log(partial);
+ * }
+ *
+ * // Get final validated object
+ * const result = await object;
+ * ```
+ */
+import { StructuredOutputError } from '../lib/errors.mjs';
+import { PartialJsonParser } from '../lib/partial-json-parser.mjs';
+import { capabilityCache } from '../lib/capability-cache.mjs';
+import { generateObject } from './generate-object.mjs';
+import { normalizeContent } from '../lib/content-converter.mjs';
+// ============================================================================
+// JSON Schema Conversion (reuse from generate-object)
+// ============================================================================
+// Dynamic import cache for zod-to-json-schema
+let loadAttempted = false;
+let cachedZodToJsonSchema = null;
+async function zodToJsonSchemaAsync(schema) {
+    if (!loadAttempted) {
+        loadAttempted = true;
+        try {
+            const zodToJsonSchemaModule = await import('zod-to-json-schema');
+            cachedZodToJsonSchema = zodToJsonSchemaModule.zodToJsonSchema;
+        }
+        catch {
+            cachedZodToJsonSchema = null;
+        }
+    }
+    if (cachedZodToJsonSchema) {
+        const result = cachedZodToJsonSchema(schema);
+        const { $schema, ...rest } = result;
+        return rest;
+    }
+    return parseZodSchemaToJsonSchema(schema);
+}
+function parseZodSchemaToJsonSchema(schema) {
+    const def = schema._def;
+    if (!def) {
+        return { type: 'object' };
+    }
+    const typeName = def.typeName;
+    switch (typeName) {
+        case 'ZodString':
+            return { type: 'string' };
+        case 'ZodNumber':
+            return { type: 'number' };
+        case 'ZodBoolean':
+            return { type: 'boolean' };
+        case 'ZodArray':
+            return {
+                type: 'array',
+                items: def.type ? parseZodSchemaToJsonSchema(def.type) : {},
+            };
+        case 'ZodObject': {
+            const shape = def.shape?.() ?? {};
+            const properties = {};
+            const required = [];
+            for (const [key, value] of Object.entries(shape)) {
+                properties[key] = parseZodSchemaToJsonSchema(value);
+                const innerDef = value?._def;
+                if (innerDef?.typeName !== 'ZodOptional') {
+                    required.push(key);
+                }
+            }
+            return {
+                type: 'object',
+                properties,
+                ...(required.length > 0 ? { required } : {}),
+            };
+        }
+        default:
+            return { type: 'object' };
+    }
+}
+// ============================================================================
+// Error Classification
+// ============================================================================
+/**
+ * Check if error indicates unsupported streaming format.
+ */
+function isUnsupportedStreamError(error) {
+    // Check error code
+    const code = error?.code;
+    if (code === 'UNSUPPORTED_STREAM_FORMAT' ||
+        code === 'INVALID_RESPONSE_FORMAT' ||
+        code === 'unsupported_response_format') {
+        return true;
+    }
+    // Check HTTP status
+    const status = error?.status;
+    if (status === 400 || status === 422) {
+        const message = String(error?.message ?? '').toLowerCase();
+        if (message.includes('stream') ||
+            message.includes('response_format') ||
+            message.includes('json_schema')) {
+            return true;
+        }
+    }
+    return false;
+}
+// ============================================================================
+// Main Function
+// ============================================================================
+/**
+ * Stream structured output with JSON schema validation.
+ */
+export async function streamObject(options) {
+    const { client, model, schema, allowFallback = false } = options;
+    // Check capability cache
+    if (capabilityCache.isNotSupported(client, model, 'stream_json_schema')) {
+        if (allowFallback) {
+            return createFallbackResult(options);
+        }
+        throw new Error(`Model ${model} does not support streaming JSON schema. Set allowFallback: true to use non-streaming.`);
+    }
+    // Try streaming
+    try {
+        return await streamObjectInternal(options);
+    }
+    catch (error) {
+        if (isUnsupportedStreamError(error)) {
+            // Cache the failure
+            capabilityCache.set(client, model, 'stream_json_schema', false);
+            if (allowFallback) {
+                console.warn('streamObject: API does not support streaming JSON schema, falling back to non-streaming');
+                return createFallbackResult(options);
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Internal streaming implementation.
+ */
+async function streamObjectInternal(options) {
+    const { client, model, schema, prompt, messages, system, temperature, topP, maxTokens, abortSignal } = options;
+    // Build messages
+    const apiMessages = [];
+    if (system) {
+        apiMessages.push({ role: 'system', content: system });
+    }
+    if (messages) {
+        apiMessages.push(...messages);
+    }
+    if (prompt) {
+        apiMessages.push({ role: 'user', content: prompt });
+    }
+    // Convert schema to JSON Schema
+    const jsonSchema = await zodToJsonSchemaAsync(schema);
+    // Build response format
+    const responseFormat = {
+        type: 'json_schema',
+        json_schema: {
+            name: 'response',
+            strict: true,
+            schema: jsonSchema,
+        },
+    };
+    // Normalize multimodal content (image -> image_url) for API compatibility
+    const normalizedMessages = apiMessages.map(msg => ({
+        ...msg,
+        content: normalizeContent(msg.content),
+    }));
+    // Create streaming request - bypass predict-node, go directly to client
+    const response = await client.chat.createStream({
+        model,
+        messages: normalizedMessages,
+        temperature,
+        top_p: topP,
+        max_tokens: maxTokens,
+        response_format: responseFormat,
+    }, { signal: abortSignal });
+    // NOTE: capabilityCache is set AFTER stream completes successfully (in background consumer)
+    // Create parser and state
+    const parser = new PartialJsonParser();
+    let rawText = '';
+    let usage;
+    let resolveObject;
+    let rejectObject;
+    let resolveRaw;
+    let resolveUsage;
+    const objectPromise = new Promise((resolve, reject) => {
+        resolveObject = resolve;
+        rejectObject = reject;
+    });
+    const rawTextPromise = new Promise((resolve) => {
+        resolveRaw = resolve;
+    });
+    const usagePromise = new Promise((resolve) => {
+        resolveUsage = resolve;
+    });
+    // Shared state for background consumer and partial stream
+    const partialValues = [];
+    let streamComplete = false;
+    let streamError = null;
+    const waiters = [];
+    // Background consumer - ensures object resolves even if partialObjectStream is not iterated
+    const backgroundConsumer = (async () => {
+        try {
+            for await (const chunk of response) {
+                const delta = chunk.choices?.[0]?.delta?.content ?? '';
+                if (delta) {
+                    rawText += delta;
+                    parser.append(delta);
+                    // Try to parse partial object
+                    const result = parser.parsePartial();
+                    if (result.value !== null) {
+                        partialValues.push(result.value);
+                        // Wake up any waiting iterators
+                        while (waiters.length > 0) {
+                            waiters.shift().resolve(false);
+                        }
+                    }
+                }
+                // Capture usage from final chunk
+                if (chunk.usage) {
+                    usage = chunk.usage;
+                }
+            }
+            // Stream complete - cache success
+            capabilityCache.set(client, model, 'stream_json_schema', true);
+            // Resolve final values
+            streamComplete = true;
+            resolveRaw(rawText);
+            resolveUsage(usage);
+            // Validate final object
+            try {
+                const parseResult = schema.safeParse(JSON.parse(rawText));
+                if (parseResult.success) {
+                    resolveObject(parseResult.data);
+                }
+                else {
+                    const validationErrors = parseResult.error.errors.map(e => ({
+                        path: e.path.map(String),
+                        message: e.message,
+                    }));
+                    const error = new StructuredOutputError('Validation failed', rawText, validationErrors);
+                    streamError = error; // Ensure partialObjectStream also throws
+                    rejectObject(error);
+                }
+            }
+            catch (e) {
+                const error = e instanceof Error ? e : new Error(String(e));
+                streamError = error; // Ensure partialObjectStream also throws
+                rejectObject(error);
+            }
+            // Wake up any waiting iterators
+            while (waiters.length > 0) {
+                waiters.shift().resolve(true);
+            }
+        }
+        catch (error) {
+            streamError = error instanceof Error ? error : new Error(String(error));
+            streamComplete = true;
+            resolveRaw(rawText);
+            resolveUsage(usage);
+            rejectObject(streamError);
+            // Wake up any waiting iterators
+            while (waiters.length > 0) {
+                waiters.shift().resolve(true);
+            }
+        }
+    })();
+    // Create async generator for partial objects (consumes from shared state)
+    async function* generatePartials() {
+        let yieldedCount = 0;
+        while (true) {
+            // Yield any new partial values
+            while (yieldedCount < partialValues.length) {
+                yield partialValues[yieldedCount++];
+            }
+            // Check if stream is complete
+            if (streamComplete) {
+                if (streamError)
+                    throw streamError;
+                break;
+            }
+            // Wait for more data
+            await new Promise((resolve) => {
+                waiters.push({ resolve });
+            });
+        }
+    }
+    return {
+        partialObjectStream: generatePartials(),
+        object: objectPromise,
+        rawText: rawTextPromise,
+        usage: usagePromise,
+        streamed: true,
+    };
+}
+/**
+ * Create fallback result using non-streaming generateObject.
+ */
+async function createFallbackResult(options) {
+    // Use generateObject (non-streaming)
+    const result = await generateObject({
+        client: options.client,
+        model: options.model,
+        schema: options.schema,
+        prompt: options.prompt,
+        messages: options.messages,
+        system: options.system,
+        temperature: options.temperature,
+        topP: options.topP,
+        maxTokens: options.maxTokens,
+        mode: 'strict',
+        abortSignal: options.abortSignal,
+    });
+    // Create single-yield async iterable
+    async function* singleYield() {
+        yield result.object;
+    }
+    return {
+        partialObjectStream: singleYield(),
+        object: Promise.resolve(result.object),
+        rawText: Promise.resolve(result.raw),
+        usage: Promise.resolve(result.usage),
+        streamed: false,
+    };
+}
+//# sourceMappingURL=stream-object.js.map

package/dist/ai/tool-approval.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Tool Approval - Unified approval mechanism for tool execution.
+ * Implements Human-in-the-Loop pattern with configurable policies.
+ */
+import type { ToolCall } from '../lib/types';
+import type { RegisteredTool, ToolSource } from '../lib/tool-registry';
+/** Context passed to approval handler */
+export interface ApprovalContext {
+    /** Tool call details */
+    toolCall: {
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    };
+    /** Tool name */
+    toolName: string;
+    /** Tool description */
+    toolDescription: string;
+    /** Parsed arguments */
+    args: Record<string, unknown>;
+    /** Current message history */
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+}
+/** Approval handler function */
+export type ApprovalHandler = (context: ApprovalContext) => Promise<boolean>;
+/** Approval configuration */
+export interface ApprovalConfig {
+    /** Global approval handler */
+    onApprovalRequired?: ApprovalHandler;
+    /**
+     * Sources to auto-approve (skip approval).
+     * Supports 'type' (e.g., 'builtin') or 'type:namespace' (e.g., 'mcp:github')
+     */
+    autoApproveSources?: string[];
+}
+/** Tool with optional approval settings */
+export interface ToolWithApproval {
+    /** Whether this tool requires approval before execution */
+    requiresApproval?: boolean;
+    /** Per-tool approval handler (overrides global) */
+    approvalHandler?: ApprovalHandler;
+}
+/** Approval result */
+export interface ApprovalResult {
+    approved: boolean;
+    /** Rejection message if not approved */
+    rejectionMessage?: string;
+}
+/** Tool-like object for approval checking */
+interface ToolForApproval {
+    name: string;
+    description?: string;
+    source?: ToolSource;
+    requiresApproval?: boolean;
+    approvalHandler?: ApprovalHandler;
+}
+/** Tool call-like object for approval checking */
+interface ToolCallForApproval {
+    id: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Determine if approval is needed and execute handler if so.
+ */
+export declare function checkApproval(tool: ToolForApproval, toolCall: ToolCallForApproval, args: Record<string, unknown>, messages: Array<{
+    role: string;
+    content: unknown;
+}>, config?: ApprovalConfig): Promise<ApprovalResult>;
+/**
+ * Execute a single tool with approval check.
+ * Returns result or rejection message.
+ */
+export declare function executeToolWithApproval(tool: RegisteredTool & ToolWithApproval, toolCall: ToolCall, args: Record<string, unknown>, messages: Array<{
+    role: string;
+    content: unknown;
+}>, config?: ApprovalConfig, abortSignal?: AbortSignal): Promise<{
+    result: string;
+    isError: boolean;
+    isRejected: boolean;
+}>;
+export {};
+//# sourceMappingURL=tool-approval.d.ts.map

package/dist/ai/tool-approval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-approval.d.ts","sourceRoot":"","sources":["../../src/ai/tool-approval.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAMvE,yCAAyC;AACzC,MAAM,WAAW,eAAe;IAC5B,wBAAwB;IACxB,QAAQ,EAAE;QACN,EAAE,EAAE,MAAM,CAAC;QACX,QAAQ,EAAE;YACN,IAAI,EAAE,MAAM,CAAC;YACb,SAAS,EAAE,MAAM,CAAC;SACrB,CAAC;KACL,CAAC;IACF,gBAAgB;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,uBAAuB;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,8BAA8B;IAC9B,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACvD;AAED,gCAAgC;AAChC,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE7E,6BAA6B;AAC7B,MAAM,WAAW,cAAc;IAC3B,8BAA8B;IAC9B,kBAAkB,CAAC,EAAE,eAAe,CAAC;IACrC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CACjC;AAED,2CAA2C;AAC3C,MAAM,WAAW,gBAAgB;IAC7B,2DAA2D;IAC3D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,mDAAmD;IACnD,eAAe,CAAC,EAAE,eAAe,CAAC;CACrC;AAED,sBAAsB;AACtB,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,wCAAwC;IACxC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AA6BD,6CAA6C;AAC7C,UAAU,eAAe;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;CACrC;AAED,kDAAkD;AAClD,UAAU,mBAAmB;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACrB,CAAC;CACL;AAED;;GAEG;AACH,wBAAsB,aAAa,CAC/B,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,mBAAmB,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EACnD,MAAM,CAAC,EAAE,cAAc,GACxB,OAAO,CAAC,cAAc,CAAC,CA+CzB;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CACzC,IAAI,EAAE,cAAc,GAAG,gBAAgB,EACvC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,EACnD,MAAM,CAAC,EAAE,cAAc,EACvB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAAC,CAoDpE"}

package/dist/ai/tool-approval.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Tool Approval - Unified approval mechanism for tool execution.
+ * Implements Human-in-the-Loop pattern with configurable policies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkApproval = checkApproval;
+exports.executeToolWithApproval = executeToolWithApproval;
+// ============================================================================
+// Rejection Message
+// ============================================================================
+const REJECTION_MESSAGE = '[Approval Rejected] Tool execution was denied by user.';
+// ============================================================================
+// Approval Logic
+// ============================================================================
+/**
+ * Check if a tool source matches an auto-approve pattern.
+ */
+function isSourceAutoApproved(source, patterns) {
+    for (const pattern of patterns) {
+        // Match full source (e.g., 'mcp:github')
+        if (pattern === `${source.type}:${source.namespace}`) {
+            return true;
+        }
+        // Match type only (e.g., 'builtin')
+        if (pattern === source.type) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Determine if approval is needed and execute handler if so.
+ */
+async function checkApproval(tool, toolCall, args, messages, config) {
+    // Tool doesn't require approval
+    if (!tool.requiresApproval) {
+        return { approved: true };
+    }
+    // Check auto-approve sources
+    if (config?.autoApproveSources && tool.source) {
+        if (isSourceAutoApproved(tool.source, config.autoApproveSources)) {
+            return { approved: true };
+        }
+    }
+    // Get handler (per-tool overrides global)
+    const handler = tool.approvalHandler ?? config?.onApprovalRequired;
+    // No handler configured but approval required - FAIL CLOSED
+    if (!handler) {
+        return {
+            approved: false,
+            rejectionMessage: '[Approval Required] No handler configured. Tool execution denied.',
+        };
+    }
+    // Execute handler
+    const context = {
+        toolCall,
+        toolName: tool.name,
+        toolDescription: tool.description ?? '',
+        args,
+        messages,
+    };
+    try {
+        const approved = await handler(context);
+        return {
+            approved,
+            rejectionMessage: approved ? undefined : REJECTION_MESSAGE,
+        };
+    }
+    catch (error) {
+        // Handler error = rejection
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            approved: false,
+            rejectionMessage: `[Approval Error] ${errorMessage}`,
+        };
+    }
+}
+/**
+ * Execute a single tool with approval check.
+ * Returns result or rejection message.
+ */
+async function executeToolWithApproval(tool, toolCall, args, messages, config, abortSignal) {
+    // Check approval
+    const approvalResult = await checkApproval(tool, toolCall, args, messages, config);
+    if (!approvalResult.approved) {
+        return {
+            result: approvalResult.rejectionMessage ?? REJECTION_MESSAGE,
+            isError: false, // Not an error, just rejected
+            isRejected: true,
+        };
+    }
+    // Check abort
+    if (abortSignal?.aborted) {
+        return {
+            result: 'Execution cancelled',
+            isError: true,
+            isRejected: false,
+        };
+    }
+    // Execute tool
+    if (!tool.execute) {
+        return {
+            result: `Tool ${tool.name} has no execute function`,
+            isError: true,
+            isRejected: false,
+        };
+    }
+    try {
+        const execContext = {
+            toolCallId: toolCall.id,
+            messages: messages,
+            abortSignal,
+        };
+        const result = await tool.execute(args, execContext);
+        return {
+            result: serializeResult(result),
+            isError: false,
+            isRejected: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            result: `Error: ${errorMessage}`,
+            isError: true,
+            isRejected: false,
+        };
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Serialize tool result to string.
+ */
+function serializeResult(result) {
+    if (result === undefined || result === null) {
+        return '';
+    }
+    if (typeof result === 'string') {
+        return result;
+    }
+    try {
+        return JSON.stringify(result, null, 2);
+    }
+    catch {
+        return String(result);
+    }
+}
+//# sourceMappingURL=tool-approval.js.map

package/dist/ai/tool-approval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-approval.js","sourceRoot":"","sources":["../../src/ai/tool-approval.ts"],"names":[],"mappings":"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"}