@lingya-ai/agents-sdk 0.4.0 → 0.7.0

package/dist/subscription.d.ts

@@ -0,0 +1,72 @@
+import { ApiError, RequestOptions } from './lifecycle';
+import { type AiChatBriefEvent } from './events';
+export interface ConnectionEvent {
+    connectionId?: string;
+    type: 'opened' | 'ready' | 'heartbeat' | 'closed';
+    transport: 'sse' | 'websocket';
+    requestId?: string;
+    reason?: string;
+    closeCode?: number;
+}
+export interface StreamOptions extends RequestOptions {
+    xRequestID?: string;
+    transport?: 'sse' | 'websocket';
+    idleTimeoutMs?: number;
+    onConnectionEvent?: (event: ConnectionEvent) => void;
+}
+export interface StreamCloseInfo {
+    reason: 'end' | 'complete' | 'normal' | 'closed' | 'cancelled' | 'timeout' | 'error';
+    error?: ApiError;
+    closeCode?: number;
+}
+export interface WebSocketLike {
+    serverRequestId?: string;
+    handshakeError?: ApiError;
+    onopen: ((event: any) => void) | null;
+    onmessage: ((event: {
+        data: any;
+    }) => void) | null;
+    onerror: ((event: any) => void) | null;
+    onclose: ((event: {
+        code: number;
+        reason: string;
+    }) => void) | null;
+    close(code?: number, reason?: string): void;
+}
+export type WebSocketFactory = (url: string, options: {
+    protocols: string[];
+    headers?: Record<string, string>;
+}) => WebSocketLike;
+export type WebSocketConnector = (url: string, signal: AbortSignal, requestId?: string) => Promise<WebSocketLike>;
+export type StreamRequest = (signal: AbortSignal) => Promise<Response>;
+/** One connection, no replay, retry, UI merging or recovery policy. */
+export declare class ChatSubscription implements AsyncIterable<AiChatBriefEvent> {
+    private readonly request;
+    private readonly url;
+    private readonly messageId;
+    private readonly options;
+    private readonly connect?;
+    readonly events: AsyncIterable<AiChatBriefEvent>;
+    readonly closed: Promise<StreamCloseInfo>;
+    private readonly scope;
+    private readonly queue;
+    private wake?;
+    private done;
+    private failure?;
+    private finish;
+    private idleTimer?;
+    private reason;
+    private serverRequestId?;
+    private closeCode?;
+    private readonly connectionId;
+    constructor(request: StreamRequest, url: string, messageId: string, options?: StreamOptions, connect?: WebSocketConnector);
+    close(): void;
+    private diagnostic;
+    private activity;
+    private push;
+    private run;
+    private websocket;
+    [Symbol.asyncIterator](): AsyncGenerator<AiChatBriefEvent>;
+}
+/** Finite SSE endpoints permit EOF, while sharing cancellation and idle semantics. */
+export declare function finiteSse(request: StreamRequest, options?: StreamOptions): AsyncGenerator<string>;

package/dist/subscription.js

@@ -0,0 +1,287 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSubscription = void 0;
+exports.finiteSse = finiteSse;
+const lifecycle_1 = require("./lifecycle");
+const events_1 = require("./events");
+const sse_1 = require("./sse");
+let nextConnectionId = 0;
+/** One connection, no replay, retry, UI merging or recovery policy. */
+class ChatSubscription {
+    constructor(request, url, messageId, options = {}, connect) {
+        this.request = request;
+        this.url = url;
+        this.messageId = messageId;
+        this.options = options;
+        this.connect = connect;
+        this.events = this;
+        this.queue = [];
+        this.done = false;
+        this.reason = 'closed';
+        this.connectionId = `connection-${++nextConnectionId}`;
+        if (options.idleTimeoutMs !== undefined && (!Number.isFinite(options.idleTimeoutMs) || options.idleTimeoutMs <= 0))
+            throw new RangeError('idleTimeoutMs must be positive');
+        this.scope = new lifecycle_1.RequestScope(options);
+        this.closed = new Promise(resolve => { this.finish = resolve; });
+        void this.run();
+    }
+    close() { this.reason = 'closed'; this.scope.controller.abort(); }
+    diagnostic(type, requestId = this.serverRequestId) {
+        var _a, _b, _c;
+        try {
+            (_b = (_a = this.options).onConnectionEvent) === null || _b === void 0 ? void 0 : _b.call(_a, { type, connectionId: this.connectionId, transport: (_c = this.options.transport) !== null && _c !== void 0 ? _c : 'sse', requestId, reason: type === 'closed' ? this.reason : undefined, closeCode: this.closeCode });
+        }
+        catch ( /* Observers do not own connection state. */_d) { /* Observers do not own connection state. */ }
+    }
+    activity() {
+        clearTimeout(this.idleTimer);
+        if (this.options.idleTimeoutMs !== undefined)
+            this.idleTimer = setTimeout(() => this.scope.controller.abort(new lifecycle_1.ApiError('', '', undefined, '', { kind: 'timeout' })), this.options.idleTimeoutMs);
+    }
+    push(data) {
+        var _a;
+        const event = (0, events_1.decodeAiChatBriefEvent)(data);
+        if (this.queue.length >= 1024)
+            throw new lifecycle_1.ApiError('', '', undefined, '', { kind: 'protocol' });
+        this.queue.push(event);
+        (_a = this.wake) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (event.type === 'end') {
+            this.reason = 'end';
+            return true;
+        }
+        return false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d, _e, _f;
+            let requestId;
+            try {
+                if (this.options.transport === 'websocket')
+                    yield this.websocket();
+                else {
+                    const response = yield (0, lifecycle_1.abortable)(this.request(this.scope.signal), this.scope.signal);
+                    requestId = (_d = response.headers.get('X-Request-ID')) !== null && _d !== void 0 ? _d : undefined;
+                    this.diagnostic('opened', requestId);
+                    this.activity();
+                    try {
+                        for (var _g = true, _h = __asyncValues((0, sse_1.decodeSse)(response, this.scope.signal, comment => {
+                            this.activity();
+                            this.diagnostic(comment === 'ready' ? 'ready' : 'heartbeat', requestId);
+                        })), _j; _j = yield _h.next(), _a = _j.done, !_a; _g = true) {
+                            _c = _j.value;
+                            _g = false;
+                            const data = _c;
+                            this.activity();
+                            if (this.push(data))
+                                break;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_g && !_a && (_b = _h.return)) yield _b.call(_h);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    if (this.reason !== 'end')
+                        throw new lifecycle_1.ApiError('', '', undefined, '', { kind: 'unexpected_eof', requestId });
+                }
+            }
+            catch (error) {
+                if (!this.scope.signal.aborted || ((_e = this.options.signal) === null || _e === void 0 ? void 0 : _e.aborted) || this.scope.signal.reason instanceof lifecycle_1.ApiError) {
+                    this.failure = yield (0, lifecycle_1.normalizeError)(error, this.scope.signal);
+                    this.reason = this.failure.kind === 'timeout' ? 'timeout' : this.failure.kind === 'cancelled' ? 'cancelled' : 'error';
+                }
+            }
+            finally {
+                this.scope.controller.abort();
+                this.scope.dispose();
+                clearTimeout(this.idleTimer);
+                this.done = true;
+                (_f = this.wake) === null || _f === void 0 ? void 0 : _f.call(this);
+                this.diagnostic('closed', requestId);
+                this.finish({ reason: this.reason, error: this.failure, closeCode: this.closeCode });
+            }
+        });
+    }
+    websocket() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.connect)
+                throw new lifecycle_1.ApiError('', '', undefined, '', { kind: 'protocol' });
+            const socket = yield (0, lifecycle_1.abortable)(this.connect(this.url, this.scope.signal, this.options.xRequestID), this.scope.signal);
+            yield new Promise((resolve, reject) => {
+                let settled = false, ready = false;
+                const settle = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    this.scope.signal.removeEventListener('abort', abort);
+                    socket.onopen = socket.onmessage = socket.onerror = socket.onclose = null;
+                    try {
+                        socket.close(1000, 'client-close');
+                    }
+                    catch ( /* Already closed. */_a) { /* Already closed. */ }
+                    error ? reject(error) : resolve();
+                };
+                const abort = () => settle(new lifecycle_1.ApiError('', '', undefined, '', { kind: 'cancelled' }));
+                this.scope.signal.addEventListener('abort', abort, { once: true });
+                if (this.scope.signal.aborted) {
+                    abort();
+                    return;
+                }
+                socket.onopen = () => { this.serverRequestId = socket.serverRequestId; this.diagnostic('opened'); this.activity(); };
+                socket.onmessage = frame => {
+                    try {
+                        this.activity();
+                        if (typeof frame.data !== 'string')
+                            throw new Error('Expected text frame');
+                        const value = JSON.parse(frame.data);
+                        if (value.id !== this.messageId || typeof value.event !== 'string')
+                            throw new Error('Invalid envelope');
+                        if (value.event === 'ready') {
+                            ready = true;
+                            this.diagnostic('ready');
+                        }
+                        else if (value.event === 'complete') {
+                            this.reason = 'complete';
+                            settle();
+                        }
+                        else if (value.event === 'transport-error')
+                            throw new lifecycle_1.ApiError('', '', undefined, JSON.stringify(value.data), { kind: 'protocol' });
+                        else {
+                            if (!ready || !value.data || typeof value.data.type !== 'string')
+                                throw new Error('Invalid business frame');
+                            if (this.push(JSON.stringify(value.data)))
+                                settle();
+                        }
+                    }
+                    catch (error) {
+                        settle(error instanceof lifecycle_1.ApiError ? error : new lifecycle_1.ApiError('', '', undefined, '', { kind: 'protocol' }));
+                    }
+                };
+                socket.onerror = () => { var _a; return settle((_a = socket.handshakeError) !== null && _a !== void 0 ? _a : new lifecycle_1.ApiError('', '', undefined, '', { kind: 'network' })); };
+                socket.onclose = event => { this.closeCode = event.code; if (event.code === 1000) {
+                    this.reason = 'normal';
+                    settle();
+                }
+                else
+                    settle(new lifecycle_1.ApiError('', '', undefined, '', { kind: 'unexpected_eof' })); };
+            });
+        });
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            try {
+                for (;;) {
+                    if (this.queue.length) {
+                        yield yield __await(this.queue.shift());
+                        continue;
+                    }
+                    if (this.done) {
+                        if (this.failure)
+                            throw this.failure;
+                        return yield __await(void 0);
+                    }
+                    yield __await(new Promise(resolve => { this.wake = resolve; }));
+                }
+            }
+            finally {
+                this.close();
+                yield __await(this.closed);
+            }
+        });
+    }
+}
+exports.ChatSubscription = ChatSubscription;
+/** Finite SSE endpoints permit EOF, while sharing cancellation and idle semantics. */
+function finiteSse(request_1) {
+    return __asyncGenerator(this, arguments, function* finiteSse_1(request, options = {}) {
+        var _a, e_2, _b, _c;
+        var _d;
+        if (options.idleTimeoutMs !== undefined && (!Number.isFinite(options.idleTimeoutMs) || options.idleTimeoutMs <= 0))
+            throw new RangeError('idleTimeoutMs must be positive');
+        const scope = new lifecycle_1.RequestScope(options);
+        let timer;
+        let reason = 'closed', requestId;
+        const connectionId = `connection-${++nextConnectionId}`;
+        const diagnostic = (type) => {
+            var _a;
+            try {
+                (_a = options.onConnectionEvent) === null || _a === void 0 ? void 0 : _a.call(options, { type, transport: 'sse', connectionId, requestId, reason: type === 'closed' ? reason : undefined });
+            }
+            catch ( /* Observer only. */_b) { /* Observer only. */ }
+        };
+        const activity = () => {
+            clearTimeout(timer);
+            if (options.idleTimeoutMs !== undefined)
+                timer = setTimeout(() => scope.controller.abort(new lifecycle_1.ApiError('', '', undefined, '', { kind: 'timeout' })), options.idleTimeoutMs);
+        };
+        try {
+            if (options.transport === 'websocket')
+                throw new lifecycle_1.ApiError('', '', undefined, '', { kind: 'protocol' });
+            const response = yield __await((0, lifecycle_1.abortable)(request(scope.signal), scope.signal));
+            requestId = (_d = response.headers.get('X-Request-ID')) !== null && _d !== void 0 ? _d : undefined;
+            diagnostic('opened');
+            activity();
+            try {
+                for (var _e = true, _f = __asyncValues((0, sse_1.decodeSse)(response, scope.signal, comment => { activity(); diagnostic(comment === 'ready' ? 'ready' : 'heartbeat'); })), _g; _g = yield __await(_f.next()), _a = _g.done, !_a; _e = true) {
+                    _c = _g.value;
+                    _e = false;
+                    const data = _c;
+                    activity();
+                    yield yield __await(data);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = _f.return)) yield __await(_b.call(_f));
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            reason = 'normal';
+        }
+        catch (error) {
+            const normalized = yield __await((0, lifecycle_1.normalizeError)(error, scope.signal));
+            requestId !== null && requestId !== void 0 ? requestId : (requestId = normalized.requestId);
+            reason = normalized.kind === 'timeout' ? 'timeout' : normalized.kind === 'cancelled' ? 'cancelled' : 'error';
+            throw normalized;
+        }
+        finally {
+            scope.controller.abort();
+            scope.dispose();
+            clearTimeout(timer);
+            diagnostic('closed');
+        }
+    });
+}

package/dist/token.d.ts

@@ -0,0 +1,20 @@
+import type { WebSocketFactory } from './subscription';
+/** A fresh token must be issued for every invocation, including concurrent calls. */
+export type TokenProvider = (context: {
+    channelId: string;
+    signal?: AbortSignal;
+    fetch: typeof fetch;
+}) => string | Promise<string>;
+export interface TokenAuth {
+    type: 'token';
+    tokenProvider: TokenProvider;
+}
+export interface ClientOptions<Auth> {
+    baseUrl: string;
+    channelId: string;
+    auth: Auth;
+    fetch?: typeof fetch;
+    webSocketFactory?: WebSocketFactory;
+}
+/** Browser-safe transport: no cache, HMAC headers, redirects, or automatic retries. */
+export declare function createTokenFetch(provider: TokenProvider, channelId: string, network?: typeof fetch): typeof fetch;

package/dist/token.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTokenFetch = createTokenFetch;
+const lifecycle_1 = require("./lifecycle");
+/** Browser-safe transport: no cache, HMAC headers, redirects, or automatic retries. */
+function createTokenFetch(provider, channelId, network = globalThis.fetch) {
+    if (typeof provider !== 'function')
+        throw new Error('tokenProvider must be a function');
+    return (input, init) => __awaiter(this, void 0, void 0, function* () {
+        const request = new Request(input, init);
+        (0, lifecycle_1.checkSignal)(request.signal);
+        if (new URL(request.url).pathname.endsWith('/presign'))
+            throw new lifecycle_1.ApiError('POST', '/presign', undefined, '{"message":"presign requires HMAC authentication"}', { kind: 'authentication' });
+        if (Array.from(request.headers.keys()).some(name => name.toLowerCase().startsWith('x-openapi-'))) {
+            throw new Error('Authentication headers are managed by the SDK');
+        }
+        let token;
+        try {
+            token = yield (0, lifecycle_1.abortable)(Promise.resolve().then(() => provider({ channelId, signal: request.signal, fetch: network })), request.signal);
+        }
+        catch (_a) {
+            (0, lifecycle_1.checkSignal)(request.signal);
+            throw Object.assign(new lifecycle_1.ApiError('', '', undefined, '', { kind: 'authentication' }), { message: 'OpenAPI token provider failed' });
+        }
+        (0, lifecycle_1.checkSignal)(request.signal);
+        if (typeof token !== 'string' || !/^[\x21-\x7e]+$/.test(token))
+            throw Object.assign(new lifecycle_1.ApiError('', '', undefined, '', { kind: 'authentication' }), { message: 'Invalid OpenAPI token' });
+        const headers = new Headers(request.headers);
+        headers.set('X-OpenAPI-Token', token);
+        return (0, lifecycle_1.fetchResponse)(network, new Request(request, { headers, redirect: 'error' }));
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lingya-ai/agents-sdk",
-  "version": "0.4.0",
-  "description": "Strongly typed server-side TypeScript SDK for Lingya Agents OpenAPI",
+  "version": "0.7.0",
+  "description": "Strongly typed TypeScript SDK for Lingya Agents OpenAPI with server HMAC and browser token authentication",
   "author": "Lingya AI",
   "license": "MIT",
   "repository": {
@@ -24,11 +24,19 @@
   "module": "./dist/esm/index.js",
   "exports": {
     ".": {
+      "browser": {
+        "types": "./dist/browser.d.ts",
+        "default": "./dist/browser.js"
+      },
       "types": "./dist/index.d.ts",
       "node": "./dist/index.js",
       "import": "./dist/index.js",
       "require": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
     }
   },
   "files": [
@@ -41,22 +49,30 @@
   },
   "scripts": {
     "generate:bound": "node scripts/generate-bound-api.mjs",
-    "build": "npm run generate:bound && tsc && tsc -p tsconfig.esm.json",
-    "check": "npm run build && npm run typecheck && npm run test && npm run audit:models && npm run package:smoke",
+    "generate:finalize": "node scripts/finalize-generated.mjs",
+    "build": "tsc && tsc -p tsconfig.esm.json",
+    "check": "npm run build && npm run typecheck && npm run test && npm run audit:models && npm run package:smoke && npm run browser:smoke",
     "typecheck": "tsc -p tsconfig.types.json",
     "test": "tsx --test test/*.test.ts",
     "test:live": "tsx --test test/live.test.ts",
     "audit:models": "node scripts/audit-models.mjs",
     "package:smoke": "node scripts/package-smoke.mjs",
     "prepublishOnly": "npm run check",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "browser:smoke": "node scripts/browser-smoke.mjs",
+    "browser:102": "node scripts/browser-integration.mjs"
   },
   "devDependencies": {
     "@types/node": "^22.15.0",
+    "@types/ws": "^8.18.1",
+    "esbuild": "0.28.2",
     "tsx": "^4.20.0",
     "typescript": "^5.9.0"
   },
   "engines": {
     "node": ">=20"
+  },
+  "dependencies": {
+    "ws": "^8.18.3"
   }
 }

package/dist/esm/models/AiChatRequestBriefEvent.d.ts

@@ -1,47 +0,0 @@
-/**
- * Lingya Agents OpenAPI
- * Public, tenant-scoped Agent channel API authenticated with OPENAPI-HMAC-SHA256-V1. Studio administration endpoints are not part of this contract.
- *
- * The version of the OpenAPI document: 0.1.2
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-import type { ChatOptions } from './ChatOptions';
-import type { ChatMessage } from './ChatMessage';
-/**
- * AiChatRequestBriefEvent 的公开协议结构。 / Public contract for ai chat request brief event.
- * @export
- * @interface AiChatRequestBriefEvent
- */
-export interface AiChatRequestBriefEvent {
-    /**
-     * 类型判别值 / type discriminator。
-     */
-    type: AiChatRequestBriefEventTypeEnum;
-    /**
-     * 字段 messages / messages field。
-     */
-    messages: Array<ChatMessage>;
-    /**
-     * 字段 chatOptions / chat options field。
-     */
-    chatOptions?: ChatOptions | null;
-}
-/**
- * @export
- */
-export declare const AiChatRequestBriefEventTypeEnum: {
-    readonly ChatClientRequest: "chat-client-request";
-};
-export type AiChatRequestBriefEventTypeEnum = typeof AiChatRequestBriefEventTypeEnum[keyof typeof AiChatRequestBriefEventTypeEnum];
-/**
- * Check if a given object implements the AiChatRequestBriefEvent interface.
- */
-export declare function instanceOfAiChatRequestBriefEvent(value: object): value is AiChatRequestBriefEvent;
-export declare function AiChatRequestBriefEventFromJSON(json: any): AiChatRequestBriefEvent;
-export declare function AiChatRequestBriefEventFromJSONTyped(json: any, ignoreDiscriminator: boolean): AiChatRequestBriefEvent;
-export declare function AiChatRequestBriefEventToJSON(json: any): AiChatRequestBriefEvent;
-export declare function AiChatRequestBriefEventToJSONTyped(value?: AiChatRequestBriefEvent | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/AiChatRequestBriefEvent.js

@@ -1,59 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
- * Lingya Agents OpenAPI
- * Public, tenant-scoped Agent channel API authenticated with OPENAPI-HMAC-SHA256-V1. Studio administration endpoints are not part of this contract.
- *
- * The version of the OpenAPI document: 0.1.2
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-import { ChatOptionsFromJSON, ChatOptionsToJSON, } from './ChatOptions';
-import { ChatMessageFromJSON, ChatMessageToJSON, } from './ChatMessage';
-/**
- * @export
- */
-export const AiChatRequestBriefEventTypeEnum = {
-    ChatClientRequest: 'chat-client-request',
-};
-/**
- * Check if a given object implements the AiChatRequestBriefEvent interface.
- */
-export function instanceOfAiChatRequestBriefEvent(value) {
-    if (!('type' in value) || value['type'] === undefined)
-        return false;
-    if (value['type'] !== 'chat-client-request')
-        return false;
-    if (!('messages' in value) || value['messages'] === undefined)
-        return false;
-    return true;
-}
-export function AiChatRequestBriefEventFromJSON(json) {
-    return AiChatRequestBriefEventFromJSONTyped(json, false);
-}
-export function AiChatRequestBriefEventFromJSONTyped(json, ignoreDiscriminator) {
-    if (json == null) {
-        return json;
-    }
-    return {
-        'type': json['type'],
-        'messages': (json['messages'].map(ChatMessageFromJSON)),
-        'chatOptions': json['chatOptions'] === undefined ? undefined : json['chatOptions'] === null ? null : ChatOptionsFromJSON(json['chatOptions']),
-    };
-}
-export function AiChatRequestBriefEventToJSON(json) {
-    return AiChatRequestBriefEventToJSONTyped(json, false);
-}
-export function AiChatRequestBriefEventToJSONTyped(value, ignoreDiscriminator = false) {
-    if (value == null) {
-        return value;
-    }
-    return {
-        'type': value['type'],
-        'messages': (value['messages'].map(ChatMessageToJSON)),
-        'chatOptions': ChatOptionsToJSON(value['chatOptions']),
-    };
-}

package/dist/esm/models/AiChatResponseBriefEvent.d.ts

@@ -1,47 +0,0 @@
-/**
- * Lingya Agents OpenAPI
- * Public, tenant-scoped Agent channel API authenticated with OPENAPI-HMAC-SHA256-V1. Studio administration endpoints are not part of this contract.
- *
- * The version of the OpenAPI document: 0.1.2
- *
- *
- * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
- * https://openapi-generator.tech
- * Do not edit the class manually.
- */
-import type { Usage } from './Usage';
-import type { AssistantChatMessage } from './AssistantChatMessage';
-/**
- * AiChatResponseBriefEvent 的公开协议结构。 / Public contract for ai chat response brief event.
- * @export
- * @interface AiChatResponseBriefEvent
- */
-export interface AiChatResponseBriefEvent {
-    /**
-     * 类型判别值 / type discriminator。
-     */
-    type: AiChatResponseBriefEventTypeEnum;
-    /**
-     * 字段 assistantMessages / assistant messages field。
-     */
-    assistantMessages: Array<AssistantChatMessage>;
-    /**
-     * 字段 usage / usage field。
-     */
-    usage: Usage;
-}
-/**
- * @export
- */
-export declare const AiChatResponseBriefEventTypeEnum: {
-    readonly ChatClientResponse: "chat-client-response";
-};
-export type AiChatResponseBriefEventTypeEnum = typeof AiChatResponseBriefEventTypeEnum[keyof typeof AiChatResponseBriefEventTypeEnum];
-/**
- * Check if a given object implements the AiChatResponseBriefEvent interface.
- */
-export declare function instanceOfAiChatResponseBriefEvent(value: object): value is AiChatResponseBriefEvent;
-export declare function AiChatResponseBriefEventFromJSON(json: any): AiChatResponseBriefEvent;
-export declare function AiChatResponseBriefEventFromJSONTyped(json: any, ignoreDiscriminator: boolean): AiChatResponseBriefEvent;
-export declare function AiChatResponseBriefEventToJSON(json: any): AiChatResponseBriefEvent;
-export declare function AiChatResponseBriefEventToJSONTyped(value?: AiChatResponseBriefEvent | null, ignoreDiscriminator?: boolean): any;