@zq-silk/yui 2.0.0 → 2.2.0

package/dist/nativeAgent/model/chatCompletions.js

@@ -0,0 +1,210 @@
+import { ModelGatewayError, object, parse, protocol } from './errors.js';
+import { sseFrames } from './wire.js';
+const maxResponse = 512 * 1024;
+const maxArguments = 64 * 1024;
+function text(value) { if (typeof value !== 'string')
+    return protocol(); return value; }
+function id(value) { const s = text(value); if (!s.trim())
+    return protocol(); return s; }
+function json(value, depth = 0) {
+    if (depth > 32)
+        return false;
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return true;
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value !== 'object')
+        return false;
+    return Object.values(value).every(v => json(v, depth + 1));
+}
+function usage(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const u = object(value);
+    const values = [u.prompt_tokens, u.completion_tokens, u.total_tokens];
+    if (!values.every(n => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0))
+        return protocol();
+    return { inputTokens: u.prompt_tokens, outputTokens: u.completion_tokens, totalTokens: u.total_tokens };
+}
+function finish(content, rawCalls, reason) {
+    if (reason !== 'stop' && reason !== 'tool_calls')
+        throw new ModelGatewayError('incomplete');
+    const list = rawCalls ?? [];
+    if (!Array.isArray(list) || list.length > 8 || (reason === 'stop') !== (list.length === 0))
+        return protocol();
+    const calls = list.map(raw => {
+        const c = object(raw), f = object(c.function);
+        if (c.type !== 'function')
+            return protocol();
+        const encoded = text(f.arguments);
+        if (Buffer.byteLength(encoded) > maxArguments)
+            return protocol();
+        const args = object(parse(encoded));
+        if (!json(args) || Buffer.byteLength(JSON.stringify(args)) > maxArguments)
+            return protocol();
+        return { id: id(c.id), name: id(f.name), arguments: args };
+    });
+    if (new Set(calls.map(c => c.id)).size !== calls.length)
+        return protocol();
+    const response = calls.length ? { kind: 'tool_calls', content, calls } : { kind: 'final', content };
+    if (Buffer.byteLength(JSON.stringify(response)) > maxResponse)
+        return protocol();
+    return response;
+}
+function messageFields(m) {
+    // Refusal/legacy calls and other modalities must not silently become an empty success.
+    if (m.refusal != null || m.function_call != null || m.audio != null)
+        return protocol();
+    if (m.role !== undefined && m.role !== 'assistant')
+        return protocol();
+}
+export function createChatCompletionsAdapter() {
+    return {
+        protocol: 'chat-completions',
+        encode(request, model, stream, options) {
+            return {
+                model, stream, store: false, n: 1,
+                ...(options?.maxOutputTokens !== undefined ? { max_completion_tokens: options.maxOutputTokens } : {}),
+                ...(stream ? { stream_options: { include_usage: true } } : {}),
+                messages: request.messages.map(m => {
+                    if (m.role === 'tool')
+                        return { role: 'tool', tool_call_id: m.toolCallId, content: JSON.stringify(m.outcome) };
+                    if (m.role === 'assistant')
+                        return {
+                            role: m.role, content: m.content,
+                            ...(m.toolCalls.length ? { tool_calls: m.toolCalls.map(c => ({
+                                    id: c.id, type: 'function', function: { name: c.name, arguments: JSON.stringify(c.arguments) },
+                                })) } : {}),
+                        };
+                    return { role: m.role, content: m.content };
+                }),
+                ...(request.tools.length ? { tools: request.tools.map(t => ({
+                        type: 'function', function: { name: t.name, description: t.description, parameters: t.inputSchema },
+                    })) } : {}),
+            };
+        },
+        classify(status, body) {
+            if (status === 401 || status === 403)
+                return 'authentication';
+            const e = body && typeof body === 'object' ? body.error : undefined;
+            const fields = e && typeof e === 'object' ? e : {};
+            if (fields.code === 'insufficient_quota' || fields.type === 'insufficient_quota')
+                return 'quota';
+            if (['invalid_api_key', 'authentication_error', 'permission_error'].includes(String(fields.code))
+                || ['authentication_error', 'permission_error'].includes(String(fields.type)))
+                return 'authentication';
+            // Status alone is insufficient; never infer temporary from a free-form message.
+            return status === 429 && fields.code === 'rate_limit_exceeded'
+                && [undefined, null, 'rate_limit_error', 'tokens', 'requests'].includes(fields.type)
+                ? 'rate_limit' : 'http';
+        },
+        async decode(body, streaming, emit) {
+            if (!streaming) {
+                let source = '';
+                for await (const part of body)
+                    source += part;
+                const root = object(parse(source));
+                if (root.error != null || !Array.isArray(root.choices) || root.choices.length !== 1)
+                    return protocol();
+                const c = object(root.choices[0]), m = object(c.message);
+                if (c.index !== 0 || m.role !== 'assistant')
+                    return protocol();
+                messageFields(m);
+                const response = finish(m.content === null ? '' : text(m.content), m.tool_calls, c.finish_reason);
+                const reported = usage(root.usage);
+                return { response, ...(reported ? { usage: reported } : {}) };
+            }
+            let content = '', reason, reported;
+            let responseId, responseModel;
+            const calls = new Map();
+            for await (const { data: frame } of sseFrames(body)) {
+                if (frame === '[DONE]') {
+                    if (reason === undefined)
+                        throw new ModelGatewayError('incomplete');
+                    const ordered = [...calls.entries()].sort(([a], [b]) => a - b);
+                    if (ordered.some(([index], i) => index !== i))
+                        return protocol();
+                    return { response: finish(content, ordered.map(([, c]) => c), reason), ...(reported ? { usage: reported } : {}) };
+                }
+                const root = object(parse(frame));
+                if (root.error != null || !Array.isArray(root.choices) || root.choices.length > 1)
+                    return protocol();
+                if (root.id !== undefined) {
+                    const current = id(root.id);
+                    if (responseId !== undefined && current !== responseId)
+                        return protocol();
+                    responseId = current;
+                }
+                if (root.model !== undefined) {
+                    const current = id(root.model);
+                    if (responseModel !== undefined && current !== responseModel)
+                        return protocol();
+                    responseModel = current;
+                }
+                if (root.usage != null) {
+                    if (reported)
+                        return protocol();
+                    reported = usage(root.usage);
+                    if (reported)
+                        emit({ type: 'usage', usage: reported });
+                }
+                if (root.choices.length === 0)
+                    continue;
+                if (reason !== undefined)
+                    return protocol();
+                const c = object(root.choices[0]), delta = object(c.delta);
+                if (c.index !== 0)
+                    return protocol();
+                messageFields(delta);
+                if (delta.content != null) {
+                    const piece = text(delta.content);
+                    content += piece;
+                    emit({ type: 'text_delta', text: piece });
+                }
+                if (delta.tool_calls != null) {
+                    if (!Array.isArray(delta.tool_calls))
+                        return protocol();
+                    for (const raw of delta.tool_calls) {
+                        const d = object(raw), i = d.index;
+                        if (typeof i !== 'number' || !Number.isInteger(i) || i < 0 || i >= 8)
+                            return protocol();
+                        const prior = calls.get(i) ?? { id: '', type: '', function: { name: '', arguments: '' } };
+                        if (d.type !== undefined) {
+                            if (d.type !== 'function' || (prior.type && prior.type !== d.type))
+                                return protocol();
+                            prior.type = 'function';
+                        }
+                        if (d.id !== undefined) {
+                            if (prior.id)
+                                return protocol();
+                            prior.id = id(d.id);
+                        }
+                        const f = d.function === undefined ? {} : object(d.function);
+                        const progress = { type: 'tool_delta', index: i };
+                        if (d.id !== undefined)
+                            progress.id = prior.id;
+                        if (f.name !== undefined) {
+                            const piece = text(f.name);
+                            prior.function.name += piece;
+                            progress.name = piece;
+                        }
+                        if (f.arguments !== undefined) {
+                            const piece = text(f.arguments);
+                            prior.function.arguments += piece;
+                            progress.arguments = piece;
+                            if (Buffer.byteLength(prior.function.arguments) > maxArguments)
+                                return protocol();
+                        }
+                        calls.set(i, prior);
+                        emit(progress);
+                    }
+                }
+                if (Buffer.byteLength(content) > maxResponse)
+                    return protocol();
+                if (c.finish_reason != null)
+                    reason = c.finish_reason;
+            }
+            throw new ModelGatewayError('incomplete');
+        },
+    };
+}

package/dist/nativeAgent/model/errors.js

@@ -0,0 +1,47 @@
+const messages = {
+    configuration: 'Invalid explicit model configuration',
+    request: 'Invalid or oversized model request',
+    protocol: 'Invalid or oversized model response',
+    incomplete: 'Model response did not finish completely',
+    authentication: 'Model request authentication or access rejected',
+    quota: 'Model account quota rejected',
+    rate_limit: 'Temporary model rate limit rejection',
+    http: 'Model HTTP request failed; not eligible for automatic replay',
+    transport: 'Model transport failed; remote effects unknown',
+    cancelled: 'Model request cancelled; remote cancellation is not rollback',
+    deadline: 'Model request deadline exceeded; remote effects may be unknown',
+};
+/** No raw cause, URL, request/response bodies, headers, credentials or provider message. */
+export class ModelGatewayError extends Error {
+    code;
+    effect;
+    stopReason;
+    requestId;
+    source = 'live';
+    attempts;
+    constructor(code, effect = 'unknown', attempts = [], stopReason, requestId) {
+        super(messages[code]);
+        this.code = code;
+        this.effect = effect;
+        this.stopReason = stopReason;
+        this.requestId = requestId;
+        this.name = 'ModelGatewayError';
+        this.attempts = Object.freeze(attempts.map(a => Object.freeze({
+            ...a, ...(a.usage ? { usage: Object.freeze({ ...a.usage }) } : {}),
+        })));
+    }
+}
+export function protocol() { throw new ModelGatewayError('protocol'); }
+export function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return protocol();
+    return value;
+}
+export function parse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return protocol();
+    }
+}