@oomol-lab/open-flow 0.1.0-beta.15 → 0.1.0-beta.16

package/dist/common/control-api-conformance.js

@@ -4336,6 +4336,12 @@ function Ws(e) {
 	]));
 	return t;
 }
+cs({
+	pointer: D().max(4096).default(""),
+	offset: k().int().nonnegative().default(0),
+	limit: k().int().min(1).max(100).default(20),
+	maxBytes: k().int().min(1).max(1048576).default(15e3)
+});
 //#endregion
 //#region src/control/common/results.ts
 var Gs = Ws(), Ks = cs({
@@ -4368,11 +4374,6 @@ var Gs = Ws(), Ks = cs({
 	createdAt: D().datetime()
 });
 cs({
-	pointer: D().max(4096).default(""),
-	offset: k().int().nonnegative().default(0),
-	limit: k().int().min(1).max(100).default(20),
-	maxBytes: k().int().min(1).max(1048576).default(15e3)
-}), cs({
 	version: F(1),
 	runId: D(),
 	results: A(Js),

package/dist/common/control-api.js

@@ -4317,8 +4317,13 @@ function Is(e) {
 	return t;
 }
 //#endregion
-//#region src/control/common/results.ts
-var Ls = Is(), Rs = L({
+//#region src/control/common/resultQuery.ts
+var Ls = L({
+	pointer: j().max(4096).default(""),
+	offset: N().int().nonnegative().default(0),
+	limit: N().int().min(1).max(100).default(20),
+	maxBytes: N().int().min(1).max(1048576).default(15e3)
+}), Rs = Is(), zs = L({
 	pointer: j(),
 	type: B([
 		"object",
@@ -4330,12 +4335,12 @@ var Ls = Is(), Rs = L({
 	]),
 	length: N().int().nonnegative().optional(),
 	complete: P(),
-	value: Ls.optional()
-}), zs = Rs.extend({
+	value: Rs.optional()
+}), Bs = zs.extend({
 	offset: N().int().nonnegative(),
 	nextOffset: N().int().positive().optional(),
-	entries: F(Rs).optional()
-}), Bs = L({
+	entries: F(zs).optional()
+}), Vs = L({
 	resultId: j().min(1),
 	callId: j().min(1),
 	toolId: j().min(1),
@@ -4346,24 +4351,19 @@ var Ls = Is(), Rs = L({
 	bytes: N().int().nonnegative(),
 	digest: j().regex(/^[a-f0-9]{64}$/),
 	createdAt: j().datetime()
-}), Vs = L({
-	pointer: j().max(4096).default(""),
-	offset: N().int().nonnegative().default(0),
-	limit: N().int().min(1).max(100).default(20),
-	maxBytes: N().int().min(1).max(1048576).default(15e3)
 }), Hs = L({
 	version: V(1),
 	runId: j(),
-	results: F(Bs),
+	results: F(Vs),
 	nextAfter: j().optional()
 }), Us = L({
 	version: V(1),
 	runId: j(),
-	result: Bs,
-	page: zs
+	result: Vs,
+	page: Bs
 });
 function Ws(e) {
-	return Vs.parse(e);
+	return Ls.parse(e);
 }
 function Gs(e) {
 	return Hs.parse(e);

package/dist/common/mcp.d.ts

@@ -183,6 +183,99 @@ export declare const mcpTools: {
             };
         };
     };
+    flow_publish: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        revisionId: string;
+                        expectedLivePublicationId: string | null;
+                        idempotencyKey: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_publish_status: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        operationId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_set_enabled: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        expectedPublicationId: string;
+                        enabled: boolean;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
     flow_run: {
         description: string;
         annotations: {
@@ -221,6 +314,38 @@ export declare const mcpTools: {
             };
         };
     };
+    run_list: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        status?: "canceled" | "completed" | "failed" | "indeterminate" | "queued" | "running" | "starting" | "waiting" | undefined;
+                        cursor?: string | undefined;
+                        limit: number;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
     run_get: {
         description: string;
         annotations: {
@@ -310,6 +435,101 @@ export declare const mcpTools: {
             };
         };
     };
+    run_results: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        runId: string;
+                        after?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    run_result_read: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        pointer: string;
+                        offset: number;
+                        limit: number;
+                        maxBytes: number;
+                        runId: string;
+                        resultId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    run_resolve_wait: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        runId: string;
+                        waitId: string;
+                        action: "approve" | "continue" | "reject";
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
     run_cancel: {
         description: string;
         annotations: {