feat: release v0.84.0 with full pending changes

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
coso
2026-03-12 00:34:23 +08:00
co-authored by Claude Opus 4.6
parent bfacf764b7
commit 2aa83ee7fc
268 changed files with 21727 additions and 6006 deletions
+633
View File
@@ -0,0 +1,633 @@
/**
* Agent / Aster 现役运行时 API
*
* 仅保留当前仍在维护的进程、会话、流式与交互能力。
*/
import { safeInvoke } from "@/lib/dev-bridge";
import type { ToolResultImage } from "./agentStream";
/**
* Agent 状态
*/
export interface AgentProcessStatus {
running: boolean;
base_url?: string;
port?: number;
}
/**
* 创建会话响应
*/
export interface CreateSessionResponse {
session_id: string;
credential_name: string;
credential_uuid: string;
provider_type: string;
model?: string;
execution_strategy?: AsterExecutionStrategy;
}
export type AsterExecutionStrategy = "react" | "code_orchestrated" | "auto";
/**
* 会话信息
*/
export interface SessionInfo {
session_id: string;
provider_type: string;
model?: string;
title?: string;
created_at: string;
last_activity: string;
messages_count: number;
workspace_id?: string;
working_dir?: string;
execution_strategy?: AsterExecutionStrategy;
}
/**
* 图片输入
*/
export interface ImageInput {
data: string;
media_type: string;
}
/**
* Skill 信息
*/
export interface SkillInfo {
name: string;
description?: string;
path?: string;
}
const requireWorkspaceId = (
workspaceId?: string,
fallbackWorkspaceId?: string,
): string => {
const resolvedWorkspaceId = (workspaceId ?? fallbackWorkspaceId)?.trim();
if (!resolvedWorkspaceId) {
throw new Error("workspaceId 不能为空,请先选择项目工作区");
}
return resolvedWorkspaceId;
};
/**
* Aster Agent 状态
*/
export interface AsterAgentStatus {
initialized: boolean;
provider_configured: boolean;
provider_name?: string;
model_name?: string;
}
/**
* Aster Provider 配置
*/
export interface AsterProviderConfig {
provider_id?: string;
provider_name: string;
model_name: string;
api_key?: string;
base_url?: string;
}
export interface AutoContinueRequestPayload {
enabled: boolean;
fast_mode_enabled: boolean;
continuation_length: number;
sensitivity: number;
source?: string;
}
/**
* Aster 会话信息(匹配后端 SessionInfo 结构)
*/
export interface AsterSessionInfo {
id: string;
name?: string;
created_at: number;
updated_at: number;
messages_count?: number;
execution_strategy?: AsterExecutionStrategy;
}
/**
* TauriMessageContent(匹配后端 TauriMessageContent 枚举)
*/
export interface TauriMessageContent {
type: string;
text?: string;
id?: string;
action_type?: string;
data?: unknown;
tool_name?: string;
arguments?: unknown;
success?: boolean;
output?: string;
error?: string;
images?: ToolResultImage[];
mime_type?: string;
}
/**
* Aster 会话详情(匹配后端 SessionDetail 结构)
*/
export interface AsterSessionDetail {
id: string;
name?: string;
created_at: number;
updated_at: number;
execution_strategy?: AsterExecutionStrategy;
messages: Array<{
id?: string;
role: string;
content: TauriMessageContent[];
timestamp: number;
}>;
}
interface InvokeAsterChatStreamOptions {
message: string;
sessionId: string;
eventName: string;
workspaceId: string;
images?: ImageInput[];
providerConfig?: AsterProviderConfig;
executionStrategy?: AsterExecutionStrategy;
webSearch?: boolean;
autoContinue?: AutoContinueRequestPayload;
systemPrompt?: string;
projectId?: string;
}
const invokeAsterChatStream = async ({
message,
sessionId,
eventName,
workspaceId,
images,
providerConfig,
executionStrategy,
webSearch,
autoContinue,
systemPrompt,
projectId,
}: InvokeAsterChatStreamOptions): Promise<void> => {
const resolvedWorkspaceId = requireWorkspaceId(workspaceId, projectId);
return await safeInvoke("aster_agent_chat_stream", {
request: {
message,
session_id: sessionId,
event_name: eventName,
images,
provider_config: providerConfig,
project_id: projectId,
workspace_id: resolvedWorkspaceId,
execution_strategy: executionStrategy,
web_search: webSearch,
auto_continue: autoContinue,
system_prompt: systemPrompt,
},
});
};
/**
* 启动 Agent(初始化原生 Agent)
*/
export async function startAgentProcess(): Promise<AgentProcessStatus> {
return await safeInvoke("agent_start_process", {});
}
/**
* 停止 Agent
*/
export async function stopAgentProcess(): Promise<void> {
return await safeInvoke("agent_stop_process");
}
/**
* 获取 Agent 状态
*/
export async function getAgentProcessStatus(): Promise<AgentProcessStatus> {
return await safeInvoke("agent_get_process_status");
}
/**
* 创建 Agent 会话
*/
export async function createAgentSession(
providerType: string,
workspaceId: string,
model?: string,
systemPrompt?: string,
skills?: SkillInfo[],
executionStrategy?: AsterExecutionStrategy,
): Promise<CreateSessionResponse> {
const resolvedWorkspaceId = requireWorkspaceId(workspaceId);
return await safeInvoke("agent_create_session", {
providerType,
model,
systemPrompt,
skills,
workspaceId: resolvedWorkspaceId,
executionStrategy,
});
}
/**
* 获取会话列表
*/
export async function listAgentSessions(): Promise<SessionInfo[]> {
return await safeInvoke("agent_list_sessions");
}
/**
* 获取会话详情
*/
export async function getAgentSession(sessionId: string): Promise<SessionInfo> {
return await safeInvoke("agent_get_session", {
sessionId,
});
}
/**
* 删除会话
*/
export async function deleteAgentSession(sessionId: string): Promise<void> {
return await safeInvoke("agent_delete_session", {
sessionId,
});
}
/**
* Agent 消息内容类型
*/
export type AgentMessageContent =
| string
| Array<
| { type: "text"; text: string }
| { type: "image_url"; image_url: { url: string; detail?: string } }
>;
/**
* 工具调用
*/
export interface AgentToolCall {
id: string;
type: string;
function: {
name: string;
arguments: string;
};
}
/**
* Agent 消息
*/
export interface AgentMessage {
role: string;
content: AgentMessageContent;
timestamp: string;
tool_calls?: AgentToolCall[];
tool_call_id?: string;
}
/**
* 获取会话消息列表
*/
export async function getAgentSessionMessages(
sessionId: string,
): Promise<AgentMessage[]> {
return await safeInvoke("agent_get_session_messages", {
sessionId,
});
}
/**
* 重命名会话(更新标题)
*/
export async function renameAgentSession(
sessionId: string,
title: string,
): Promise<void> {
return await safeInvoke("agent_rename_session", {
sessionId,
title,
});
}
/**
* 生成智能标题
*/
export async function generateAgentTitle(sessionId: string): Promise<string> {
return await safeInvoke("agent_generate_title", {
sessionId,
});
}
/**
* 初始化 Aster Agent
*/
export async function initAsterAgent(): Promise<AsterAgentStatus> {
return await safeInvoke("aster_agent_init");
}
/**
* 获取 Aster Agent 状态
*/
export async function getAsterAgentStatus(): Promise<AsterAgentStatus> {
return await safeInvoke("aster_agent_status");
}
/**
* 配置 Aster Agent 的 Provider
*/
export async function configureAsterProvider(
config: AsterProviderConfig,
sessionId: string,
): Promise<AsterAgentStatus> {
return await safeInvoke("aster_agent_configure_provider", {
request: config,
session_id: sessionId,
});
}
/**
* 发送消息到 Aster Agent (流式响应)
*
* 通过 Tauri 事件接收响应流
*/
export async function sendAsterMessageStream(
message: string,
sessionId: string,
eventName: string,
workspaceId: string,
images?: ImageInput[],
providerConfig?: AsterProviderConfig,
executionStrategy?: AsterExecutionStrategy,
webSearch?: boolean,
autoContinue?: AutoContinueRequestPayload,
systemPrompt?: string,
projectId?: string,
): Promise<void> {
return await invokeAsterChatStream({
message,
sessionId,
eventName,
workspaceId,
images,
providerConfig,
executionStrategy,
webSearch,
autoContinue,
systemPrompt,
projectId,
});
}
/**
* 停止 Aster Agent 会话
*/
export async function stopAsterSession(sessionId: string): Promise<boolean> {
return await safeInvoke("aster_agent_stop", { sessionId });
}
/**
* 创建 Aster 会话
*/
export async function createAsterSession(
workspaceId: string,
workingDir?: string,
name?: string,
executionStrategy?: AsterExecutionStrategy,
): Promise<string> {
const resolvedWorkspaceId = requireWorkspaceId(workspaceId);
return await safeInvoke("aster_session_create", {
workingDir,
workspaceId: resolvedWorkspaceId,
name,
executionStrategy,
});
}
/**
* 获取 Aster 会话列表
*/
export async function listAsterSessions(): Promise<AsterSessionInfo[]> {
return await safeInvoke("aster_session_list");
}
/**
* 获取 Aster 会话详情
*/
export async function getAsterSession(
sessionId: string,
): Promise<AsterSessionDetail> {
return await safeInvoke("aster_session_get", { sessionId });
}
/**
* 重命名 Aster 会话
*/
export async function renameAsterSession(
sessionId: string,
name: string,
): Promise<void> {
return await safeInvoke("aster_session_rename", { sessionId, name });
}
/**
* 设置 Aster 会话执行策略
*/
export async function setAsterSessionExecutionStrategy(
sessionId: string,
executionStrategy: AsterExecutionStrategy,
): Promise<void> {
return await safeInvoke("aster_session_set_execution_strategy", {
sessionId,
executionStrategy,
});
}
/**
* 删除 Aster 会话
*/
export async function deleteAsterSession(sessionId: string): Promise<void> {
return await safeInvoke("aster_session_delete", { sessionId });
}
/**
* 确认 Aster Agent 权限请求
*/
export async function confirmAsterAction(
requestId: string,
confirmed: boolean,
response?: string,
): Promise<void> {
return await safeInvoke("aster_agent_confirm", {
request: {
request_id: requestId,
confirmed,
response,
},
});
}
/**
* 提交 Aster Agent elicitation 响应
*/
export async function submitAsterElicitationResponse(
sessionId: string,
requestId: string,
userData: unknown,
): Promise<void> {
return await safeInvoke("aster_agent_submit_elicitation_response", {
sessionId,
request: {
request_id: requestId,
user_data: userData,
},
});
}
/**
* 终端命令请求(从后端发送到前端)
*/
export interface TerminalCommandRequest {
/** 请求 ID */
request_id: string;
/** 要执行的命令 */
command: string;
/** 工作目录(可选) */
working_dir?: string;
/** 超时时间(秒) */
timeout_secs: number;
}
/**
* 终端命令响应(从前端发送到后端)
*/
export interface TerminalCommandResponse {
/** 请求 ID */
request_id: string;
/** 是否成功 */
success: boolean;
/** 输出内容 */
output: string;
/** 错误信息 */
error?: string;
/** 退出码 */
exit_code?: number;
/** 是否被用户拒绝 */
rejected: boolean;
}
/**
* 发送终端命令响应到后端
*
* 当用户批准或拒绝命令后,调用此函数将结果发送给 TerminalTool
*/
export async function sendTerminalCommandResponse(
response: TerminalCommandResponse,
): Promise<void> {
return await safeInvoke("agent_terminal_command_response", {
requestId: response.request_id,
success: response.success,
output: response.output,
error: response.error,
exitCode: response.exit_code,
rejected: response.rejected,
});
}
/**
* 终端滚动缓冲区请求(从后端发送到前端)
*/
export interface TermScrollbackRequest {
/** 请求 ID */
request_id: string;
/** 终端会话 ID */
session_id: string;
/** 起始行号(可选,从 0 开始) */
line_start?: number;
/** 读取行数(可选) */
count?: number;
}
/**
* 终端滚动缓冲区响应(从前端发送到后端)
*/
export interface TermScrollbackResponse {
/** 请求 ID */
request_id: string;
/** 是否成功 */
success: boolean;
/** 总行数 */
total_lines: number;
/** 实际返回的起始行号 */
line_start: number;
/** 实际返回的结束行号 */
line_end: number;
/** 输出内容 */
content: string;
/** 是否还有更多内容 */
has_more: boolean;
/** 错误信息 */
error?: string;
}
/**
* 发送终端滚动缓冲区响应到后端
*
* 当前端读取终端输出历史后,调用此函数将结果发送给 TermScrollbackTool
*/
export async function sendTermScrollbackResponse(
response: TermScrollbackResponse,
): Promise<void> {
return await safeInvoke("agent_term_scrollback_response", {
requestId: response.request_id,
success: response.success,
totalLines: response.total_lines,
lineStart: response.line_start,
lineEnd: response.line_end,
content: response.content,
hasMore: response.has_more,
error: response.error,
});
}
/**
* 权限确认响应
*/
export interface PermissionResponse {
/** 请求 ID */
requestId: string;
/** 是否确认 */
confirmed: boolean;
/** 响应内容(用户输入或选择的答案) */
response?: string;
}
/**
* 发送权限确认响应到后端
*
* 当用户确认或拒绝权限请求后,调用此函数将结果发送给 Agent
*/
export async function sendPermissionResponse(
response: PermissionResponse,
): Promise<void> {
return await safeInvoke("aster_agent_confirm", {
request: {
request_id: response.requestId,
confirmed: response.confirmed,
response: response.response,
},
});
}