agent-chat-sdk-core 0.1.0

package/dist/cjs/parser.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStreamEndSignal = isStreamEndSignal;
+exports.parseSSELine = parseSSELine;
+exports.readSSEStream = readSSEStream;
+const STREAM_END_TYPES = new Set(['done', 'end', 'finish', 'completed', 'stop']);
+const TOOL_LIKE_TYPES = new Set([
+    'tool',
+    'knowledge',
+    'plugin',
+    'mcp',
+    'memory_var_update',
+    'workflow',
+]);
+function extractWorkflowResponse(parsed) {
+    const response = parsed.response;
+    if (response === undefined || response === null)
+        return '';
+    if (typeof response === 'object' && response !== null) {
+        const output = response.output;
+        if (output !== undefined && output !== null)
+            return String(output);
+        return JSON.stringify(response);
+    }
+    const text = String(response);
+    try {
+        const json = JSON.parse(text);
+        if (json.output !== undefined && json.output !== null)
+            return String(json.output);
+    }
+    catch {
+        // response 为纯文本
+    }
+    return text;
+}
+function asRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return undefined;
+}
+function stringifyOutputValue(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'object')
+        return JSON.stringify(value, null, 2);
+    return String(value);
+}
+/** 从 outputs 对象中提取首选文本字段 */
+function extractOutputsContent(outputs) {
+    const preferredKeys = ['output', 'text', 'result', 'answer', 'content'];
+    for (const key of preferredKeys) {
+        const text = stringifyOutputValue(outputs[key]).trim();
+        if (text)
+            return text;
+    }
+    const entries = Object.entries(outputs).filter(([, v]) => stringifyOutputValue(v).trim());
+    if (entries.length === 0)
+        return '';
+    return entries.map(([k, v]) => `${k}:\n${stringifyOutputValue(v)}`).join('\n\n');
+}
+/**
+ * 工作流直连 Invoke 的 SSE 事件（event: workflow_* / node_* / text_chunk）
+ */
+function extractWorkflowInvokeContent(parsed, eventType) {
+    const data = asRecord(parsed.data);
+    // 累积型 answer（常见于 message / agent_message）
+    if ((eventType === 'message' || eventType === 'agent_message') &&
+        parsed.answer !== undefined &&
+        parsed.answer !== null) {
+        return String(parsed.answer);
+    }
+    // 流式增量：data.text / delta / chunk
+    if (data && eventType !== 'workflow_started' && eventType !== 'workflow_finished') {
+        const streamDelta = data.text ?? data.delta ?? data.chunk ?? data.answer;
+        if (streamDelta !== undefined && streamDelta !== null) {
+            const text = String(streamDelta);
+            if (text)
+                return text;
+        }
+    }
+    if (eventType === 'text_chunk' || eventType === 'message' || eventType === 'agent_message') {
+        const text = data?.text ?? data?.answer ?? data?.content ?? parsed.text ?? parsed.answer;
+        if (text !== undefined && text !== null)
+            return String(text);
+    }
+    if (eventType === 'node_finished' || eventType === 'node_started') {
+        const text = data?.text ?? data?.title;
+        if (text)
+            return String(text);
+    }
+    if (data?.outputs && eventType !== 'workflow_started') {
+        const fromOutputs = extractOutputsContent(asRecord(data.outputs) ?? {});
+        if (fromOutputs)
+            return fromOutputs;
+    }
+    if (eventType === 'workflow_finished' && data) {
+        const outputs = asRecord(data.outputs);
+        if (outputs) {
+            const fromOutputs = extractOutputsContent(outputs);
+            if (fromOutputs)
+                return fromOutputs;
+        }
+        if (data.error)
+            return String(data.error);
+    }
+    if (eventType === 'workflow_failed' && data?.error) {
+        return String(data.error);
+    }
+    return '';
+}
+function isWorkflowInvokeEvent(type) {
+    return (type.startsWith('workflow_') ||
+        type.startsWith('node_') ||
+        type === 'text_chunk' ||
+        type === 'message' ||
+        type === 'agent_message' ||
+        type === 'agent_thought' ||
+        type === 'llm_chunk' ||
+        type === 'generation' ||
+        type.includes('_chunk') ||
+        type.includes('_delta'));
+}
+/** 预审工作流流式输出：event=answer 且 text 在 data.text */
+function isWorkflowStreamAnswer(parsed, type) {
+    return type === 'answer' && typeof parsed.workflow_run_id === 'string';
+}
+function extractChunkContent(parsed, type) {
+    if (type === 'workflow') {
+        const fromResponse = extractWorkflowResponse(parsed);
+        if (fromResponse)
+            return fromResponse;
+        const direct = parsed.content ?? parsed.text ?? parsed.delta;
+        if (direct !== undefined && direct !== null && String(direct) !== '') {
+            return String(direct);
+        }
+        return '';
+    }
+    if (type === 'memory_var_update') {
+        const content = parsed.content ?? parsed.text ?? parsed.delta;
+        if (content !== undefined && content !== null && String(content) !== '') {
+            return String(content);
+        }
+        if (parsed.description !== undefined && parsed.description !== null) {
+            return String(parsed.description);
+        }
+        return '';
+    }
+    const direct = parsed.content ?? parsed.text ?? parsed.delta;
+    if (direct !== undefined && direct !== null && String(direct) !== '') {
+        return String(direct);
+    }
+    if (TOOL_LIKE_TYPES.has(type)) {
+        if (parsed.response !== undefined && parsed.response !== null) {
+            return String(parsed.response);
+        }
+        if (parsed.arg !== undefined && parsed.arg !== null) {
+            return String(parsed.arg);
+        }
+    }
+    return '';
+}
+function isStreamEndSignal(type, dataStr) {
+    return dataStr === '[DONE]' || STREAM_END_TYPES.has(type);
+}
+/**
+ * 解析单行 SSE 文本
+ * @returns 原始分片 | 'end' 流结束 | null 跳过
+ */
+function parseSSELine(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith(':'))
+        return null;
+    if (trimmed.startsWith('event:')) {
+        const eventName = trimmed.slice(6).trim();
+        if (STREAM_END_TYPES.has(eventName))
+            return 'end';
+        if (eventName === 'error') {
+            return { type: 'error', content: '执行出错，请稍后重试' };
+        }
+        return null;
+    }
+    const dataStr = trimmed.startsWith('data: ') ? trimmed.slice(6).trim() : trimmed;
+    if (!dataStr)
+        return null;
+    if (isStreamEndSignal('', dataStr))
+        return 'end';
+    try {
+        const parsed = JSON.parse(dataStr);
+        const type = String(parsed.type ?? parsed.event ?? 'answer');
+        if (isStreamEndSignal(type, ''))
+            return 'end';
+        if (isWorkflowStreamAnswer(parsed, type)) {
+            const data = asRecord(parsed.data);
+            const text = data?.text;
+            if (text === undefined || text === null)
+                return null;
+            return {
+                type: 'workflow_answer',
+                content: String(text),
+                raw: parsed,
+            };
+        }
+        if (isWorkflowInvokeEvent(type)) {
+            if (type === 'workflow_failed') {
+                const errMsg = extractWorkflowInvokeContent(parsed, type) ||
+                    String(asRecord(parsed.data)?.error ?? '工作流执行失败');
+                return {
+                    type: 'error',
+                    content: errMsg,
+                    error: errMsg,
+                    raw: parsed,
+                };
+            }
+            const content = extractWorkflowInvokeContent(parsed, type);
+            if (type === 'workflow_started' || type === 'workflow_finished' || content) {
+                return { type, content, raw: parsed };
+            }
+            return null;
+        }
+        if (type === 'error') {
+            return {
+                type: 'error',
+                content: String(parsed.error ?? parsed.message ?? '执行出错，请稍后重试'),
+                error: parsed.error,
+                error_detail: (parsed.error_detail ?? parsed.errorDetail),
+                raw: parsed,
+            };
+        }
+        const chunk = {
+            type,
+            content: extractChunkContent(parsed, type),
+            role: parsed.role,
+            running_time: parsed.running_time,
+            raw: parsed,
+        };
+        if (chunk.content ||
+            chunk.type === 'thinking' ||
+            TOOL_LIKE_TYPES.has(chunk.type) ||
+            (chunk.type === 'workflow' && chunk.running_time)) {
+            return chunk;
+        }
+        return null;
+    }
+    catch {
+        return dataStr ? { type: 'answer', content: dataStr } : null;
+    }
+}
+/**
+ * 从 ReadableStream 读取并解析 SSE，逐条回调
+ */
+async function readSSEStream(body, onChunk, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    try {
+        streamLoop: while (true) {
+            if (signal?.aborted) {
+                await reader.cancel();
+                break;
+            }
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                const parsed = parseSSELine(line);
+                if (parsed === 'end') {
+                    try {
+                        await reader.cancel();
+                    }
+                    catch {
+                        // 连接可能已由服务端关闭
+                    }
+                    break streamLoop;
+                }
+                if (parsed)
+                    onChunk(parsed);
+            }
+        }
+        if (buffer.trim()) {
+            const parsed = parseSSELine(buffer);
+            if (parsed && parsed !== 'end')
+                onChunk(parsed);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/cjs/react-flow.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * ReAct 智能体流式交互时序说明
+ *
+ * ┌─────────────┐
+ * │ 用户点击发送 │
+ * └──────┬──────┘
+ *        ▼
+ * ┌─────────────────────┐     SSE POST
+ * │ 展示回复气泡 + Loading │ ◄──────────── 接口
+ * └──────┬──────────────┘
+ *        ▼ 首个 SSE 字段
+ * ┌──────────────────────────────────────────────────┐
+ * │  ReAct 循环（可多轮）                                │
+ * │  ① thinking_start                                 │
+ * │  ② thinking_delta*  → UI: 「深度思考中...」（不展示内容）│
+ * │  ③ thinking_end     → UI: 「深度思考成功，用时 Xs」   │
+ * │  ④ tool_call_start  → UI: 「工具/知识库调用中...」    │
+ * │  ⑤ tool_call_end    → UI: 「XX成功，用时 Xs」        │
+ * │     └── 可能回到 ① 继续思考                         │
+ * └──────────────────────┬───────────────────────────┘
+ *                        ▼
+ *              answer_delta*  → 流式输出最终回复
+ *                        ▼
+ *                 stream_end
+ *
+ * 对应 SSE type 字段：
+ * - thinking / tool / knowledge / plugin / mcp / memory_var_update / answer / error / done
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REACT_SSE_TYPE_MAP = void 0;
+exports.REACT_SSE_TYPE_MAP = {
+    thinking: '思考阶段',
+    tool: '工具调用',
+    knowledge: '知识库调用',
+    plugin: '插件调用',
+    mcp: 'MCP 调用',
+    memory_var_update: '记忆变量更新',
+    workflow: '工作流调用',
+    answer: '最终回答',
+    error: '错误',
+};

package/dist/cjs/session.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSessionState = createSessionState;
+exports.applyEventToSession = applyEventToSession;
+function createSessionState(query) {
+    return {
+        status: 'streaming',
+        query,
+        thinkingContent: '',
+        isThinking: false,
+        answerContent: '',
+        processes: [],
+    };
+}
+let processIdSeq = 0;
+function nextProcessId() {
+    processIdSeq += 1;
+    return `proc_${processIdSeq}_${Date.now()}`;
+}
+function upsertProcess(processes, id, item) {
+    const index = processes.findIndex((p) => p.id === id);
+    if (index >= 0) {
+        const next = [...processes];
+        next[index] = { ...next[index], ...item };
+        return next;
+    }
+    return [...processes, item];
+}
+/**
+ * 根据标准化事件更新会话聚合状态（ReAct 多轮）
+ */
+function applyEventToSession(state, event) {
+    switch (event.type) {
+        case 'stream_start':
+            return { ...state, status: 'streaming', query: event.query };
+        case 'thinking_start':
+            return { ...state, isThinking: true, thinkingContent: '' };
+        case 'thinking_delta':
+            return { ...state, isThinking: true, thinkingContent: event.content };
+        case 'thinking_end':
+            return {
+                ...state,
+                isThinking: false,
+                thinkingContent: event.content,
+                processes: event.content
+                    ? [
+                        ...state.processes,
+                        {
+                            id: nextProcessId(),
+                            type: 'thinking',
+                            title: '深度思考',
+                            time: event.runningTime || '0',
+                            content: event.content,
+                            status: 'completed',
+                        },
+                    ]
+                    : state.processes,
+            };
+        case 'tool_call_start':
+        case 'knowledge_call_start':
+            return {
+                ...state,
+                isThinking: false,
+                processes: upsertProcess(state.processes, event.toolId, {
+                    id: event.toolId,
+                    type: event.callKind,
+                    title: event.title,
+                    time: '0',
+                    content: '',
+                    status: 'running',
+                }),
+            };
+        case 'tool_call_end':
+        case 'knowledge_call_end':
+            return {
+                ...state,
+                processes: upsertProcess(state.processes, event.toolId, {
+                    id: event.toolId,
+                    type: event.callKind,
+                    title: event.title,
+                    time: event.runningTime || '0',
+                    content: event.content,
+                    status: 'completed',
+                }),
+            };
+        case 'answer_delta':
+            return { ...state, answerContent: event.content };
+        case 'error':
+            return {
+                ...state,
+                status: 'error',
+                isThinking: false,
+                error: { message: event.message, detail: event.detail },
+            };
+        case 'stream_end':
+            return { ...state, status: state.status === 'error' ? 'error' : 'completed', isThinking: false };
+        default:
+            return state;
+    }
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/client.d.ts

@@ -0,0 +1,45 @@
+import { AgentChatClientConfig, AgentChatStreamHandlers, AgentChatStreamOptions, AgentStreamEvent } from './types.js';
+/**
+ * 智能体流式对话客户端
+ *
+ * @example
+ * ```ts
+ * const client = new AgentChatClient({
+ *   url: 'https://your-host/appforge/openapi/v1/InvokeApp/app-xxx',
+ *   appId: 'app-xxx',
+ *   appKey: 'your-key',
+ * });
+ *
+ * await client.chatStream(
+ *   { query: '你好', dataMode: 'normalized' },
+ *   {
+ *     onEvent: (event) => {
+ *       if (event.type === 'answer_delta') {
+ *         console.log(event.content);
+ *       }
+ *     },
+ *   },
+ * );
+ * ```
+ */
+export declare class AgentChatClient {
+    private config;
+    private abortController;
+    constructor(config: AgentChatClientConfig);
+    /** 更新配置 */
+    updateConfig(config: Partial<AgentChatClientConfig>): void;
+    getConfig(): Readonly<AgentChatClientConfig>;
+    /** 中止当前流式请求 */
+    abort(): void;
+    /** 当前配置的请求 URL */
+    getUrl(): string;
+    /**
+     * 发起流式对话
+     */
+    chatStream(options: AgentChatStreamOptions, handlers?: AgentChatStreamHandlers): Promise<void>;
+    /**
+     * 以 AsyncIterable 消费流式事件（便于 for-await）
+     */
+    streamEvents(options: AgentChatStreamOptions): AsyncGenerator<AgentStreamEvent, void, undefined>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/esm/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,qBAAqB,EAErB,uBAAuB,EACvB,sBAAsB,EACtB,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAuBpB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,eAAe,CAAgC;gBAE3C,MAAM,EAAE,qBAAqB;IAIzC,WAAW;IACX,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,IAAI;IAI1D,SAAS,IAAI,QAAQ,CAAC,qBAAqB,CAAC;IAI5C,eAAe;IACf,KAAK,IAAI,IAAI;IAKb,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACG,UAAU,CACd,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,GAAE,uBAA4B,GACrC,OAAO,CAAC,IAAI,CAAC;IA2FhB;;OAEG;IACI,YAAY,CACjB,OAAO,EAAE,sBAAsB,GAC9B,cAAc,CAAC,gBAAgB,EAAE,IAAI,EAAE,SAAS,CAAC;CAkDrD"}

package/dist/esm/client.js

@@ -0,0 +1,195 @@
+import { readSSEStream } from './parser.js';
+import { createNormalizeContext, finalizeNormalizeContext, normalizeRawChunk, } from './normalizer.js';
+const DEFAULT_BUILD_BODY = (query, config) => ({
+    id: config.appId,
+    query,
+});
+const DEFAULT_BUILD_HEADERS = (config) => {
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+    };
+    if (config.appKey) {
+        headers.Authorization = `Bearer ${config.appKey}`;
+    }
+    return headers;
+};
+/**
+ * 智能体流式对话客户端
+ *
+ * @example
+ * ```ts
+ * const client = new AgentChatClient({
+ *   url: 'https://your-host/appforge/openapi/v1/InvokeApp/app-xxx',
+ *   appId: 'app-xxx',
+ *   appKey: 'your-key',
+ * });
+ *
+ * await client.chatStream(
+ *   { query: '你好', dataMode: 'normalized' },
+ *   {
+ *     onEvent: (event) => {
+ *       if (event.type === 'answer_delta') {
+ *         console.log(event.content);
+ *       }
+ *     },
+ *   },
+ * );
+ * ```
+ */
+export class AgentChatClient {
+    constructor(config) {
+        this.abortController = null;
+        this.config = config;
+    }
+    /** 更新配置 */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    /** 中止当前流式请求 */
+    abort() {
+        this.abortController?.abort();
+        this.abortController = null;
+    }
+    /** 当前配置的请求 URL */
+    getUrl() {
+        return this.config.url;
+    }
+    /**
+     * 发起流式对话
+     */
+    async chatStream(options, handlers = {}) {
+        const { query, signal, dataMode = 'normalized', extraBody = {}, extraHeaders = {}, } = options;
+        this.abort();
+        const controller = new AbortController();
+        this.abortController = controller;
+        const combinedSignal = signal
+            ? combineAbortSignals(signal, controller.signal)
+            : controller.signal;
+        const emit = (event) => handlers.onEvent?.(event);
+        const emitRaw = (chunk) => handlers.onRawChunk?.(chunk);
+        const shouldEmitNormalized = dataMode === 'normalized' || dataMode === 'both';
+        const shouldEmitRaw = dataMode === 'raw' || dataMode === 'both';
+        if (shouldEmitNormalized) {
+            emit({ type: 'stream_start', timestamp: Date.now(), query });
+        }
+        const normCtx = createNormalizeContext();
+        try {
+            const fetchImpl = this.config.fetch ?? globalThis.fetch;
+            const url = this.config.url;
+            const buildBody = this.config.buildRequestBody ?? DEFAULT_BUILD_BODY;
+            const buildHeaders = this.config.buildHeaders ?? DEFAULT_BUILD_HEADERS;
+            const response = await fetchImpl(url, {
+                method: 'POST',
+                headers: { ...buildHeaders(this.config), ...extraHeaders },
+                body: JSON.stringify({ ...buildBody(query, this.config), ...extraBody }),
+                signal: combinedSignal,
+                cache: 'no-store',
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText || response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is empty');
+            }
+            await readSSEStream(response.body, (rawChunk) => {
+                if (shouldEmitRaw)
+                    emitRaw(rawChunk);
+                if (shouldEmitNormalized) {
+                    const events = normalizeRawChunk(rawChunk, normCtx);
+                    events.forEach(emit);
+                }
+            }, combinedSignal);
+            if (shouldEmitNormalized) {
+                finalizeNormalizeContext(normCtx).forEach(emit);
+                emit({ type: 'stream_end', timestamp: Date.now() });
+            }
+            handlers.onComplete?.();
+        }
+        catch (error) {
+            if (combinedSignal.aborted)
+                return;
+            const err = error instanceof Error ? error : new Error(String(error));
+            handlers.onError?.(err);
+            if (shouldEmitNormalized) {
+                emit({
+                    type: 'error',
+                    timestamp: Date.now(),
+                    message: err.message,
+                });
+                emit({ type: 'stream_end', timestamp: Date.now() });
+            }
+            throw err;
+        }
+        finally {
+            if (this.abortController === controller) {
+                this.abortController = null;
+            }
+        }
+    }
+    /**
+     * 以 AsyncIterable 消费流式事件（便于 for-await）
+     */
+    async *streamEvents(options) {
+        const queue = [];
+        let resolveWait = null;
+        let done = false;
+        let streamError = null;
+        const notify = () => {
+            resolveWait?.();
+            resolveWait = null;
+        };
+        const runPromise = this.chatStream({ ...options, dataMode: options.dataMode ?? 'normalized' }, {
+            onEvent: (event) => {
+                queue.push(event);
+                notify();
+            },
+            onError: (err) => {
+                streamError = err;
+                done = true;
+                notify();
+            },
+            onComplete: () => {
+                done = true;
+                notify();
+            },
+        }).catch((err) => {
+            streamError = err;
+            done = true;
+            notify();
+        });
+        try {
+            while (true) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                    continue;
+                }
+                if (done)
+                    break;
+                await new Promise((resolve) => {
+                    resolveWait = resolve;
+                });
+            }
+            if (streamError)
+                throw streamError;
+        }
+        finally {
+            await runPromise.catch(() => undefined);
+        }
+    }
+}
+function combineAbortSignals(...signals) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    signals.forEach((s) => {
+        if (s.aborted)
+            controller.abort();
+        else
+            s.addEventListener('abort', onAbort, { once: true });
+    });
+    return controller.signal;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,9 @@
+export { AgentChatClient } from './client.js';
+export { parseSSELine, readSSEStream, isStreamEndSignal } from './parser.js';
+export { normalizeRawChunk, createNormalizeContext, finalizeNormalizeContext, } from './normalizer.js';
+export { createSessionState, applyEventToSession } from './session.js';
+export { REACT_SSE_TYPE_MAP } from './react-flow.js';
+export { parseKnowledgeSupLabels, stripKnowledgeSupLabels, } from './knowledge-label.js';
+export type { KnowledgeCitationLabel, ParseKnowledgeLabelsResult } from './knowledge-label.js';
+export type { AgentChatClientConfig, AgentChatDataMode, AgentChatProcessItem, AgentChatSessionState, AgentChatStreamHandlers, AgentChatStreamOptions, AgentStreamEvent, AgentStreamEventType, RawSSEChunk, StreamStartEvent, StreamEndEvent, ThinkingStartEvent, ThinkingDeltaEvent, ThinkingEndEvent, AnswerDeltaEvent, ToolCallStartEvent, ToolCallEndEvent, ProcessCallKind, ErrorEvent, RawEvent, } from './types.js';
+//# sourceMappingURL=index.d.ts.map