@oomol-lab/open-flow 0.1.0-beta.14 → 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),
@@ -4661,7 +4662,7 @@ var I = D(), L = Ws(), Ys = A(I), Xs = j({
 	outputs: A(Xs.extend({ sources: A(M([Qs, $s])) }))
 }), xc = j({
 	nodes: N(I, _c),
-	edges: A(yc)
+	edges: A(yc).default([])
 }), Sc = j({
 	kind: P(["connection", "variable"]),
 	target: I

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);
@@ -4748,7 +4748,7 @@ var H = j(), U = Is(), Qs = F(H), $s = I({
 	outputs: F($s.extend({ sources: F(R([tc, nc])) }))
 }), wc = I({
 	nodes: z(H, bc),
-	edges: F(Sc)
+	edges: F(Sc).default([])
 }), Tc = I({
 	kind: B(["connection", "variable"]),
 	target: H

package/dist/common/control-requests.js

@@ -4644,7 +4644,7 @@ var K = F(), q = Ks(), Js = z(K), Ys = B({
 	outputs: z(Ys.extend({ sources: z(H([Zs, Qs])) }))
 }), bc = B({
 	nodes: U(K, gc),
-	edges: z(vc)
+	edges: z(vc).default([])
 }), xc = B({
 	kind: W(["connection", "variable"]),
 	target: K

package/dist/common/flow-encoding.js

@@ -4532,7 +4532,7 @@ var q = fo(), J = Ds(), As = V(q), js = H({
 	outputs: V(js.extend({ sources: V(U([Ns, Ps])) }))
 }), tc = H({
 	nodes: W(q, Zs),
-	edges: V($s)
+	edges: V($s).default([])
 }), nc = H({
 	kind: G(["connection", "variable"]),
 	target: q

package/dist/common/flow-semantics.js

@@ -5257,7 +5257,7 @@ var j = w(), Mc = Ac(), Nc = D(j), Pc = O({
 	outputs: D(Pc.extend({ sources: D(k([Lc, Rc])) }))
 }), sl = O({
 	nodes: tc(j, nl),
-	edges: D(il)
+	edges: D(il).default([])
 }), cl = O({
 	kind: rc(["connection", "variable"]),
 	target: j

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: {