@seastudio/sdk 3.0.0

package/dist/mcp/plugin-seaflow/index.d.ts

@@ -0,0 +1,318 @@
+import { k as MCPToolResult, g as MCPTool } from '../../types-Clgf5gBf.js';
+
+/**
+ * SeaFlow Plugin MCP Tools
+ *
+ * SeaFlow 插件提供的 MCP Tools（B 类插件，画布执行与编排）
+ */
+
+declare const canvasContextTools: MCPTool[];
+declare const canvasExecutionTools: MCPTool[];
+declare const canvasAuthTools: MCPTool[];
+declare const canvasExtendedTools: MCPTool[];
+declare const tools: MCPTool[];
+declare const allTools: MCPTool[];
+declare const seaflow: {
+    getSnapshot: (graphId?: string) => Promise<MCPToolResult>;
+    getWorkflowContext: () => Promise<MCPToolResult>;
+    clearCanvas: () => Promise<MCPToolResult>;
+    listNodeTypes: (options?: {
+        includeBasic?: boolean;
+        includeAliases?: boolean;
+        includeCapabilities?: boolean;
+        includeSchemas?: boolean;
+        executableOnly?: boolean;
+        typeIds?: string[];
+    }) => Promise<MCPToolResult>;
+    batchApply: (operations: Array<Record<string, unknown>>, options: {
+        requestId: string;
+        idempotencyKey: string;
+        baseVersion: number;
+    }) => Promise<MCPToolResult>;
+    validateNode: (nodeId: string, strict?: boolean) => Promise<MCPToolResult>;
+    getNodeOutputs: (nodeId: string) => Promise<MCPToolResult>;
+    getNode: (nodeId: string) => Promise<MCPToolResult>;
+    listEdges: (options?: {
+        nodeId?: string;
+        direction?: "in" | "out" | "both";
+    }) => Promise<MCPToolResult>;
+    executeNode: (nodeId: string, target?: "seaart" | "staging") => Promise<MCPToolResult>;
+    executeGraph: (graphId?: string, target?: "seaart" | "staging", source?: "auto" | "remote" | "local") => Promise<MCPToolResult>;
+    openWorkflow: (workflowId: string, options?: {
+        target?: "seaart" | "staging";
+        source?: "auto" | "remote" | "local";
+        syncActiveGraph?: boolean;
+    }) => Promise<MCPToolResult>;
+    saveWorkflow: (options?: {
+        workflowId?: string;
+        name?: string;
+        target?: "seaart" | "staging";
+        persistLocal?: boolean;
+        persistRemote?: boolean;
+        includeViewport?: boolean;
+        isCanvas?: boolean;
+        versionId?: string;
+    }) => Promise<MCPToolResult>;
+    cancelTask: (taskId: string) => Promise<MCPToolResult>;
+    getTaskState: (taskId: string) => Promise<MCPToolResult>;
+    listTasks: (options?: {
+        status?: CanvasTaskStatus;
+        nodeId?: string;
+    }) => Promise<MCPToolResult>;
+    waitTaskResult: (taskId: string, options?: {
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+        includeEvents?: boolean;
+    }) => Promise<MCPToolResult>;
+    reconnectTask: (options?: {
+        taskId?: string;
+        nodeId?: string;
+        target?: "seaart" | "staging";
+        timeoutMs?: number;
+        includeEvents?: boolean;
+    }) => Promise<MCPToolResult>;
+    getExecutionAuth: () => Promise<MCPToolResult>;
+    setExecutionAuth: (target: "seaart" | "staging", token: string, persistMode?: "memory" | "session" | "local") => Promise<MCPToolResult>;
+    upsertImageNode: (input: {
+        nodeId?: string;
+        label?: string;
+        prompt: string;
+        negativePrompt?: string;
+        model?: string;
+        mode?: string;
+        resolution?: string;
+        aspectRatio?: string;
+        seed?: number;
+        nIter?: number;
+        width?: number;
+        height?: number;
+    }) => Promise<MCPToolResult>;
+    upsertTextNode: (input: {
+        nodeId?: string;
+        label?: string;
+        prompt: string;
+        model?: string;
+        negativePrompt?: string;
+        systemPrompt?: string;
+        modalMode?: "text" | "image_to_text" | "video_to_text";
+        maxTokens?: number;
+        temperature?: number;
+        topP?: number;
+    }) => Promise<MCPToolResult>;
+    connectNodes: (input: {
+        sourceNodeId: string;
+        targetNodeId: string;
+        sourceField?: string;
+        targetField?: string;
+        sourceHandle?: string;
+        targetHandle?: string;
+        edgeType?: string;
+    }) => Promise<MCPToolResult>;
+    executeNodeAndWait: (nodeId: string, options?: {
+        target?: "seaart" | "staging";
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+        includeEvents?: boolean;
+    }) => Promise<MCPToolResult>;
+    generateImageFromPrompt: (input: {
+        nodeId?: string;
+        label?: string;
+        prompt: string;
+        negativePrompt?: string;
+        model?: string;
+        mode?: string;
+        resolution?: string;
+        aspectRatio?: string;
+        seed?: number;
+        nIter?: number;
+        width?: number;
+        height?: number;
+        target?: "seaart" | "staging";
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }) => Promise<MCPToolResult>;
+};
+type CanvasTaskStatus = 'accepted' | 'queued' | 'running' | 'completed' | 'failed' | 'error' | 'canceled';
+interface CanvasBatchApplyResult {
+    accepted: boolean;
+    nextVersion?: number;
+    appliedCount?: number;
+    conflicts?: Array<{
+        code: string;
+        message: string;
+        operationIndex?: number;
+    }>;
+}
+interface CanvasWorkflowContextResult {
+    activeWorkflowId: string;
+    graphId: string;
+    version: number;
+    nodeCount: number;
+    edgeCount: number;
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    autosaveStorageKey?: string;
+    target?: string;
+    updatedAt?: number;
+}
+interface CanvasClearCanvasResult {
+    accepted: boolean;
+    graphId?: string;
+    clearedNodeCount?: number;
+    clearedEdgeCount?: number;
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    updatedAt?: number;
+}
+interface CanvasWorkflowOpenResult {
+    accepted: boolean;
+    workflowId?: string;
+    source?: 'remote' | 'local';
+    nodeCount?: number;
+    edgeCount?: number;
+    name?: string;
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    reason?: string;
+}
+interface CanvasWorkflowSaveResult {
+    accepted: boolean;
+    workflowId?: string;
+    localSaved?: boolean;
+    remoteSaved?: boolean;
+    remoteError?: string;
+    nodeCount?: number;
+    edgeCount?: number;
+    viewport?: {
+        x: number;
+        y: number;
+        zoom: number;
+    };
+    updatedAt?: string;
+    reason?: string;
+}
+interface CanvasExecutionTaskState {
+    taskId: string;
+    target?: string;
+    status: CanvasTaskStatus;
+    progress?: number;
+    message?: string;
+    updatedAt?: number;
+}
+type CanvasExecutionAuthState = 'READY' | 'MISSING' | 'INVALID';
+type CanvasExecutionPersistMode = 'memory' | 'session' | 'local';
+interface CanvasExecutionAuthSnapshot {
+    currentTarget: string;
+    persistMode: CanvasExecutionPersistMode;
+    authStateByTarget: Record<string, CanvasExecutionAuthState>;
+    hasTokenByTarget: Record<string, boolean>;
+    updatedAt?: number;
+}
+interface CanvasRuntimeDirective {
+    kind: 'call_tool' | 'await_tool_result' | 'finalize' | 'fail';
+    toolName?: string;
+    input?: Record<string, unknown>;
+    finalText?: string;
+    reason?: string;
+    code?: string;
+}
+interface CanvasTaskWaitResult {
+    accepted: boolean;
+    taskId: string;
+    target?: string;
+    status: CanvasTaskStatus;
+    progress?: number;
+    message?: string;
+    terminal: boolean;
+    result?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    eventsProcessed?: number;
+    updatedAt?: number;
+    runtimeDirective?: CanvasRuntimeDirective;
+}
+interface CanvasTaskReconnectItem {
+    accepted: boolean;
+    taskId?: string;
+    target?: string;
+    status?: CanvasTaskStatus;
+    progress?: number;
+    message?: string;
+    terminal?: boolean;
+    outputs?: Record<string, unknown>;
+    result?: Record<string, unknown>;
+    eventsProcessed?: number;
+    updatedAt?: number;
+    reason?: string;
+}
+interface CanvasTaskReconnectResult {
+    accepted: boolean;
+    total: number;
+    acceptedCount: number;
+    terminalCount: number;
+    items: CanvasTaskReconnectItem[];
+    updatedAt?: number;
+    reason?: string;
+}
+interface CanvasNodeValidationResult {
+    nodeId: string;
+    nodeType?: string;
+    valid: boolean;
+    errors: string[];
+    warnings?: string[];
+}
+interface CanvasNodeOutputsResult {
+    nodeId: string;
+    outputs: Record<string, unknown>;
+    selectedOutputUrlIndex?: number;
+    updatedAt?: number;
+}
+interface CanvasNodeDetailResult {
+    nodeId: string;
+    nodeType: string;
+    position?: Record<string, unknown>;
+    selected?: boolean;
+    label?: string;
+    inputs: Record<string, unknown>;
+    runtime: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+    updatedAt?: number;
+}
+interface CanvasEdgeListItem {
+    id: string;
+    source: string;
+    sourceHandle?: string;
+    target: string;
+    targetHandle?: string;
+    type?: string;
+}
+interface CanvasEdgeListResult {
+    total: number;
+    items: CanvasEdgeListItem[];
+    updatedAt?: number;
+}
+interface CanvasTaskListItem {
+    taskId: string;
+    nodeId?: string;
+    nodeType?: string;
+    target?: string;
+    status: CanvasTaskStatus;
+    progress?: number;
+    message?: string;
+    updatedAt?: number;
+}
+interface CanvasTaskListResult {
+    total: number;
+    items: CanvasTaskListItem[];
+    updatedAt?: number;
+}
+
+export { type CanvasBatchApplyResult, type CanvasClearCanvasResult, type CanvasEdgeListItem, type CanvasEdgeListResult, type CanvasExecutionAuthSnapshot, type CanvasExecutionAuthState, type CanvasExecutionPersistMode, type CanvasExecutionTaskState, type CanvasNodeDetailResult, type CanvasNodeOutputsResult, type CanvasNodeValidationResult, type CanvasRuntimeDirective, type CanvasTaskListItem, type CanvasTaskListResult, type CanvasTaskReconnectItem, type CanvasTaskReconnectResult, type CanvasTaskStatus, type CanvasTaskWaitResult, type CanvasWorkflowContextResult, type CanvasWorkflowOpenResult, type CanvasWorkflowSaveResult, allTools, canvasAuthTools, canvasContextTools, canvasExecutionTools, canvasExtendedTools, seaflow, tools };

package/dist/mcp/plugin-seaflow/index.js

@@ -0,0 +1,2 @@
+export { allTools, canvasAuthTools, canvasContextTools, canvasExecutionTools, canvasExtendedTools, seaflow, tools } from '../../chunk-4ITOR5QE.js';
+import '../../chunk-ANWOL7SM.js';

package/dist/mcp/seastudio/index.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var chunkAGBZJGTY_cjs = require('../../chunk-AGBZJGTY.cjs');
+require('../../chunk-TFOJLA2F.cjs');
+
+
+
+Object.defineProperty(exports, "SeastudioNotifications", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.SeastudioNotifications; }
+});
+Object.defineProperty(exports, "SeastudioRequests", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.SeastudioRequests; }
+});
+Object.defineProperty(exports, "agentManagementTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.agentManagementTools; }
+});
+Object.defineProperty(exports, "agentTabTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.agentTabTools; }
+});
+Object.defineProperty(exports, "allTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.allTools; }
+});
+Object.defineProperty(exports, "annotateTool", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.annotateTool; }
+});
+Object.defineProperty(exports, "batchFileTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.batchFileTools; }
+});
+Object.defineProperty(exports, "clipboardTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.clipboardTools; }
+});
+Object.defineProperty(exports, "codeQualityTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.codeQualityTools; }
+});
+Object.defineProperty(exports, "fileTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.fileTools; }
+});
+Object.defineProperty(exports, "gitTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.gitTools; }
+});
+Object.defineProperty(exports, "pluginManagementTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.pluginManagementTools; }
+});
+Object.defineProperty(exports, "pluginTabTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.pluginTabTools; }
+});
+Object.defineProperty(exports, "seaCloudTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.seaCloudTools; }
+});
+Object.defineProperty(exports, "seastudio", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.seastudio; }
+});
+Object.defineProperty(exports, "shellTools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.shellTools; }
+});
+Object.defineProperty(exports, "tools", {
+  enumerable: true,
+  get: function () { return chunkAGBZJGTY_cjs.tools; }
+});